Feat: Remove supergfxctl notification daemon

Add slash support for additional ga403 2025 models

See merge request asus-linux/asusctl!238

.cargo-husky/hooks/post-commit

@@ -0,0 +1,53 @@
+#!/bin/sh
+set -e
+
+ROOT_DIR=$(git rev-parse --show-toplevel)
+AURA_DATA="${ROOT_DIR}/rog-aura/data/aura_support.ron"
+SPEC_FILE="${ROOT_DIR}/distro-packaging/asusctl.spec"
+TRANSLATION="${ROOT_DIR}/rog-control-center/translations/en/rog-control-center.po"
+VERSION=$(grep -Pm1 'version = "(\d+.\d+.\d+.*)"' "${ROOT_DIR}/Cargo.toml" | cut -d'"' -f2)
+
+if [ -z "$VERSION" ]; then
+    echo "Error: Could not extract version from Cargo.toml"
+    exit 1
+fi
+if [ ! -f "$SPEC_FILE" ]; then
+    echo "Error: Spec file not found at ${SPEC_FILE}"
+    exit 1
+fi
+
+# Update spec file
+sed -i "s/^%define version.*/%define version ${VERSION}/" "$SPEC_FILE"
+if git diff --quiet "$SPEC_FILE"; then
+    echo "No changes to spec file"
+else
+    git add "$SPEC_FILE"
+    git commit --no-verify -m "chore: update spec file version to ${VERSION}"
+    echo "Updated spec file version to ${VERSION}"
+fi
+
+# Update translations only if UI files changed
+if git diff-tree -r HEAD@{1} HEAD --name-only | grep -q "^rog-control-center/ui/"; then
+    echo 'find -name \*.slint | xargs slint-tr-extractor -o ${TRANSLATION}'
+    find -name \*.slint | xargs slint-tr-extractor -o $TRANSLATION
+    if git diff --quiet "$TRANSLATION"; then
+        echo "No changes to translation file"
+    else
+        git add "$TRANSLATION"
+        git commit --no-verify -m "chore: update translations"
+        echo "Updated ${TRANSLATION}"
+    fi
+else
+    echo "No changes in rog-control-center/ui/, skipping translation update"
+fi
+
+# Update aura data
+cargo test --package rog_aura --lib -- aura_detection::tests::check_data_file_parse --exact
+cargo test --package rog_aura --lib -- aura_detection::tests::find_data_file_groups --exact
+if git diff --quiet "$AURA_DATA"; then
+    echo "No changes to aura data file"
+else
+    git add "$AURA_DATA"
+    git commit --no-verify -m "chore: update aura data"
+    echo "Updated $AURA_DATA"
+fi

.cargo-husky/hooks/pre-commit

@@ -0,0 +1,6 @@
+#!/bin/sh
+set -e
+
+echo '+cargo fmt --all -- --check'
+cargo fmt --all -- --check
+git add -u

.cargo-husky/hooks/pre-push

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo fmt --all -- --check'
+cargo fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo cranky'
+cargo cranky

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rs]
+indent_size = 4
+
+[tests/**/*.rs]
+charset = utf-8
+end_of_line = unset
+indent_size = unset
+indent_style = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset

.gitignore

@@ -2,6 +2,21 @@
 vendor.tar.xz
 cargo-config
 .idea
+vendor
 vendor-*
 vendor_*
 .vscode-ctags
+.vscode
+.~lock.*
+*.ods#
+*.patch
+
+# gnome extension
+node-modules
+bindings/ts/*.d.ts
+bindings/ts/*.js.map
+desktop-extensions/gnome*/dist
+desktop-extensions/gnome*/@types/gir-generated
+desktop-extensions/gnome*/node_modules
+desktop-extensions/gnome*/schemas/gschemas.compiled
+desktop-extensions/gnome*/*.zip

.gitlab-ci.yml

@@ -1,26 +1,99 @@
-image: rustdocker/rust:stable
-
-before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev
-
-stages:
-    - test
-    - build
-
-test:
-  script:
-    - cargo check #+nightly check --features "clippy"
-
-build:
-  only:
-    - main
-  script:
-    - make && make vendor
-  artifacts:
-    paths:
-    - vendor_asus-nb-ctrl_*.tar.xz
-    - cargo-config
+image: rust:latest
 
+# Use shallow clone to reduce checkout size
 variables:
+  GIT_DEPTH: "1"
+  # Put cargo home and target under project dir so we can clean them easily
+  CARGO_HOME: "$CI_PROJECT_DIR/.cargo"
+  CARGO_TARGET_DIR: "$CI_PROJECT_DIR/ci-target"
   GIT_SUBMODULE_STRATEGY: normal
 
+# Cache only cargo registries/git metadata to speed dependency fetches.
+# Avoid caching compiled `target` artifacts which are large and easily fill disk.
+.rust_cache: &rust_cache
+  cache:
+    key: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
+    paths:
+      - .cargo/registry
+      - .cargo/git
+
+before_script:
+  - df -h
+  - echo "Cleaning stale targets to free space if present"
+  - rm -rf "$CI_PROJECT_DIR/target" "$CI_PROJECT_DIR/ci-target" || true
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev libsdl2-dev libsdl2-gfx-dev
+
+stages:
+  - format
+  - check
+  - test
+  - release
+  - deploy
+
+format:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - rustup component add rustfmt || true
+    - cargo fmt --check
+  after_script:
+    - du -sh "$CI_PROJECT_DIR/ci-target" || true
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
+
+check:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - rustup component add clippy || true
+    - cargo check --locked --workspace
+    # deny currently catches too much
+    #- cargo install cargo-deny && cargo deny
+    - cargo install cargo-cranky && cargo cranky
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
+
+test:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test --locked --all
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
+
+release:
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo install cargo-vendor-filterer
+    - cargo fetch
+    - make FROZEN=1 && make vendor
+  artifacts:
+    paths:
+      - vendor_asusctl*.tar.xz
+      - cargo-config
+    expire_in: 1 week
+  after_script:
+    - rm -rf vendor vendor_asusctl*.tar.xz "$CI_PROJECT_DIR/ci-target" || true
+
+pages:
+  stage: deploy
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo doc --locked --document-private-items --no-deps --workspace
+    - rm -rf public
+    - mkdir public
+    - cp -R ci-target/doc/* public
+    - cp extra/index.html public
+  artifacts:
+    paths:
+      - public
+    expire_in: 1 week
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true

.gitlab/issue_templates/default.md

@@ -0,0 +1,32 @@
+## Issue description
+
+(** I can not support distros which are outdated by default. This includes Ubuntu at least 50% of the time, and definitely includes Mint. **)
+(Summarize the bug encountered)
+
+## Steps to reproduce
+
+(How can the issue be reproduced)
+
+## What is the current bug behavior?
+
+(What actually happens)
+
+## What is the expected correct behavior?
+
+(What you should see instead)
+
+## Relevant logs and/or screenshots
+
+(run `journalctl -b -u asusd > ~/asusd.log` and attach `~/asusd.log`)
+
+(Paste any relevant logs - use code blocks (```) to format console output, logs, and code, as
+it's very hard to read otherwise.)
+
+## System details
+
+- Distro:
+- Kernel: (`uname -r`)
+- Desktop:
+- Xorg or wayland: ??
+
+/label ~bug ~reproducable ~needs-investigation

Cargo.toml

@@ -1,16 +1,97 @@
+[workspace.package]
+version = "6.2.0"
+rust-version = "1.82"
+license = "MPL-2.0"
+readme = "README.md"
+authors = ["Luke <luke@ljones.dev>"]
+repository = "https://gitlab.com/asus-linux/asusctl"
+homepage = "https://gitlab.com/asus-linux/asusctl"
+description = "Laptop feature control for ASUS ROG laptops and others"
+edition = "2021"
+
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
+resolver = "2"
+members = [
+  "asusctl",
+  "asusd",
+  "asusd-user",
+  "config-traits",
+  "dmi-id",
+  "rog-platform",
+  "rog-dbus",
+  "rog-anime",
+  "rog-aura",
+  "rog-profiles",
+  "rog-control-center",
+  "rog-slash",
+  "simulators",
+  "rog-scsi",
+]
+
+default-members = ["asusctl", "asusd", "asusd-user", "rog-control-center"]
+
+[workspace.dependencies]
+tokio = { version = "^1.39.0", default-features = false, features = [
+  "macros",
+  "sync",
+  "time",
+  "rt",
+  "rt-multi-thread",
+] }
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^2.0"
+mio = "0.8.11"
+
+futures-util = "0.3.31"
+zbus = "5.13.1"
+logind-zbus = { version = "5.2.0" } #, default-features = false, features = ["non_blocking"] }
+
+serde = { version = "^1.0", features = ["serde_derive"] }
+ron = "*"
+
+log = "^0.4"
+env_logger = "^0.10.0"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = { version = "^0.8", features = ["mio"] }
+rusb = "^0.9"
+inotify = "^0.10"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.4"
+gif = "^0.12"
+
+versions = "6.2"
+
+notify-rust = { version = "4.11.5", features = ["z", "async"] }
+
+sg = { git = "https://github.com/flukejones/sg-rs.git" }
 
 [profile.release]
-lto = true
+# thin = 57s, asusd = 9.0M
+# fat = 72s, asusd = 6.4M
+lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"
+# codegen-units = 1
 
 [profile.dev]
-debug = false
 opt-level = 1
+# codegen-units = 1
+
+[profile.dev.package."*"]
+opt-level = 1
+# codegen-units = 1
 
 [profile.bench]
 debug = false
 opt-level = 3
+
+[workspace.dependencies.cargo-husky]
+version = "1"
+default-features = false
+features = ["user-hooks"]

Cranky.toml

@@ -0,0 +1,121 @@
+# https://github.com/ericseppanen/cargo-cranky
+# cargo install cargo-cranky && cargo cranky
+
+error = [
+  "clippy::all",
+  "clippy::await_holding_lock",
+  "clippy::bool_to_int_with_if",
+  "clippy::char_lit_as_u8",
+  "clippy::checked_conversions",
+  "clippy::dbg_macro",
+  "clippy::debug_assert_with_mut_call",
+  "clippy::disallowed_methods",
+  "clippy::disallowed_script_idents",
+  "clippy::doc_link_with_quotes",
+  "clippy::doc_markdown",
+  "clippy::empty_enum",
+  "clippy::enum_glob_use",
+  "clippy::equatable_if_let",
+  "clippy::exit",
+  "clippy::expl_impl_clone_on_copy",
+  "clippy::explicit_deref_methods",
+  "clippy::explicit_into_iter_loop",
+  "clippy::explicit_iter_loop",
+  "clippy::fallible_impl_from",
+  "clippy::filter_map_next",
+  "clippy::flat_map_option",
+  "clippy::float_cmp_const",
+  "clippy::fn_params_excessive_bools",
+  "clippy::fn_to_numeric_cast_any",
+  "clippy::from_iter_instead_of_collect",
+  "clippy::if_let_mutex",
+  "clippy::implicit_clone",
+  "clippy::imprecise_flops",
+  "clippy::index_refutable_slice",
+  "clippy::inefficient_to_string",
+  "clippy::invalid_upcast_comparisons",
+  "clippy::iter_not_returning_iterator",
+  "clippy::iter_on_empty_collections",
+  "clippy::iter_on_single_items",
+  "clippy::large_digit_groups",
+  "clippy::large_stack_arrays",
+  "clippy::large_types_passed_by_value",
+  "clippy::let_unit_value",
+  "clippy::linkedlist",
+  "clippy::lossy_float_literal",
+  "clippy::macro_use_imports",
+  "clippy::manual_assert",
+  "clippy::manual_instant_elapsed",
+  "clippy::manual_ok_or",
+  "clippy::manual_string_new",
+  "clippy::map_err_ignore",
+  "clippy::map_flatten",
+  "clippy::map_unwrap_or",
+  "clippy::match_on_vec_items",
+  "clippy::match_same_arms",
+  "clippy::match_wild_err_arm",
+  "clippy::match_wildcard_for_single_variants",
+  "clippy::mem_forget",
+  "clippy::mismatched_target_os",
+  "clippy::mismatching_type_param_order",
+  "clippy::missing_enforced_import_renames",
+  # "clippy::missing_errors_doc",
+  "clippy::missing_safety_doc",
+  "clippy::mut_mut",
+  "clippy::mutex_integer",
+  "clippy::needless_borrow",
+  "clippy::needless_continue",
+  "clippy::needless_for_each",
+  "clippy::needless_pass_by_value",
+  "clippy::negative_feature_names",
+  "clippy::nonstandard_macro_braces",
+  "clippy::option_option",
+  "clippy::path_buf_push_overwrite",
+  "clippy::ptr_as_ptr",
+  "clippy::rc_mutex",
+  "clippy::ref_option_ref",
+  "clippy::rest_pat_in_fully_bound_structs",
+  "clippy::same_functions_in_if_condition",
+  "clippy::semicolon_if_nothing_returned",
+  "clippy::single_match_else",
+  "clippy::str_to_string",
+  "clippy::string_add_assign",
+  "clippy::string_add",
+  "clippy::string_lit_as_bytes",
+  "clippy::string_to_string",
+  "clippy::todo",
+  "clippy::trailing_empty_array",
+  "clippy::trait_duplication_in_bounds",
+  "clippy::unimplemented",
+  "clippy::unnecessary_wraps",
+  "clippy::unnested_or_patterns",
+  "clippy::unused_peekable",
+  "clippy::unused_rounding",
+  # "clippy::unused_self",
+  "clippy::useless_transmute",
+  "clippy::verbose_file_reads",
+  "clippy::zero_sized_map_values",
+  "elided_lifetimes_in_paths",
+  "future_incompatible",
+  "nonstandard_style",
+  "rust_2018_idioms",
+  "rust_2021_prelude_collisions",
+  "rustdoc::missing_crate_level_docs",
+  "semicolon_in_expressions_from_macros",
+  "trivial_numeric_casts",
+  "unused_extern_crates",
+  "unused_import_braces",
+  "unused_lifetimes",
+]
+
+allow = [
+  # TODO(emilk): enable more lints
+  "clippy::cloned_instead_of_copied",
+  "clippy::derive_partial_eq_without_eq",
+  "clippy::type_complexity",
+  "clippy::undocumented_unsafe_blocks",
+  "trivial_casts",
+  "unsafe_op_in_unsafe_fn",               # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
+  "unused_qualifications",
+]
+

MANUAL.md

@@ -1,5 +1,7 @@
 # asusctrl manual
 
+**NOTE:** this manual is in need of an update in some places. If you find issues please file issue reports.
+
 `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.
 
@@ -8,11 +10,10 @@ but can also be used with non-asus laptops with reduced features.
 - `asusd`: The main system daemon. It is autostarted by a udev rule and systemd unit.
 - `asusd-user`: The user level daemon. Currently will run an anime sequence, with RGB keyboard sequences soon.
 - `asusctl`: The CLI for interacting with the system daemon
-- `asus-notify`: A notification daemon with a user systemd unit that can be enabled.
 
 ## `asusd`
 
-`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a *safe* dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
+`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a _safe_ dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
 
 The functionality that `asusd` exposes is:
 
@@ -47,35 +48,7 @@ The LED controller (e.g, aura) enables setting many of the factory modes availab
 
 #### Supported laptops
 
-Models GA401, GA502, GU502 support LED brightness change only (no RGB). However the GA401Q model can actually use three modes; static, breathe, and pulse, plus also use red to control the LED brightness intensity.
-
-All models that have any form of LED mode control need to be enabled via the config file at `/etc/asusd/asusd-ledmodes.toml`. Unfortunately ASUS doesn't provide any easy way to find all the supported modes for all laptops (not even through Armory Crate and its various files, that progrma downloads only the required settings for the laptop it runs on) so each model must be added as needed.
-
-#### Config options
-
-The defaults are located at `/etc/asusd/asusd-ledmodes.toml`, and on `asusd` start it creates `/etc/asusd/aura.conf` whcih stores the per-mode settings. If you edit the defaults file you must remove `/etc/asusd/aura.conf` and restart `asusd.service` with `systemctl restart asusd`.
-
-##### /etc/asusd/asusd-ledmodes.toml
-
-Example:
-```toml
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = false
-per_key = false
-```
-
-1. `prod_family`: you can find this in `journalctl -b -u asusd`, or `cat /sys/class/dmi/id/product_name`. It should be copied as written. There can be multiple `led-data` groups of the same `prod_family` with differing `board_names`.
-2. `board_names`: is an array of board names in this product family. Find this in the journal as above or by `cat /sys/class/dmi/id/board_name`.
-3. `standard` are the factory preset modes, the names should corrospond to Armory Crate names
-4. `multizone`: some keyboards have 4 zones of LED control, this enables setting a colour in each zone. The keyboard must support this or it has no effect.
-5. `per_key`: enable per-key RGB effects. The keyboard must support this or it has no effect.
-
-##### /etc/asusd/aura.conf
-
-This file can be manually edited if desired, but the `asusctl` CLI tool, or dbus methods are the preferred method. Any manual changes to this file mean that the `asusd.service` will need to be restarted, or you need to cycle between modes to force a reload.
+There are over 80 supported laptops as of 01-01-2023. Please see [the rog-aura crate readme for further details](/rog-aura/README.md).
 
 ### Charge control
 
@@ -84,29 +57,31 @@ Almost all modern ASUS laptops have charging limit control now. This can be cont
 ```json
 "bat_charge_limit": 80,
 ```
+
 where the number is a percentage.
 
 ### Bios control
 
 Some options that you find in Armory Crate are available under this controller, so far there is:
 
-- POST sound: this is the sound you here on bios boot post
-- G-Sync: this controls if the dGPU (Nvidia) is the *only* GPU, making it the main GPU and disabling the iGPU
+- POST sound: this is the sound you hear on bios boot post
+- GPU MUX: this controls if the dGPU is the _only_ GPU, making it the main GPU and disabling the iGPU
 
 These options are not written to the config file as they are stored in efivars. The only way to change these is to use the exposed safe dbus methods, or use the `asusctl` CLI tool.
 
 ### Profiles
 
-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.9.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 included in the "rog" kernels we build for fedora and arch, and will hit kernel 5.15 upstream.
+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.
 
 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 support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/8/29/50) which is still in review as of 29/09/21. As with Profiles, this is included in the kernels we build, and will hit 5.15 kernel upstream.
+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 .
 
 The fan curve format can be of varying formats:
 
@@ -125,12 +100,121 @@ There is one more controller; the support controller. The sole pupose of this co
 
 ## asusd-user
 
-`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the *base* system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
+`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the _base_ system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
 
 As of now only AniMe is active in this with configuration in `~/.config/rog/`. On first run defaults are created that are intended to work as examples.
 
 The main config is `~/.config/rog/rog-user.cfg`
 
+#### Config options: Aura, per-key and zoned
+
+I'm unsure of how many laptops this works on, so please try it.
+
+`led_type: Key` works only on actual per-key RGB keyboards.
+
+`led_type: Zone` works on zoned laptops.
+
+`led_type: Zone` set to `None` works on zoned ROG laptops, unzoned ROG laptops, and TUF laptops (and yes this does mean an audio EQ can be done now).
+
+`~/.config/rog/rog-user.cfg` contains a setting `"active_aura": "<FILENAME>"` where `<FILENAME>` is the name of the Aura config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "aura-default"`
+
+An Aura config itself is a file with contents:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            Breathe((
+                led: W,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: A,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: S,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: D,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: F,
+                start_colour1: (255, 0, 0),
+                start_colour2: (255, 0, 0),
+                speed: High,
+            )),
+            Static((
+                led: RCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: LCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: Esc,
+                colour: (0, 0, 255),
+            )),
+            DoomFlicker((
+                led: N9,
+                start_colour: (0, 0, 255),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: false,
+    ),
+)
+```
+
+If your laptop supports multizone, `"led"` can also be `"Zone": <one of the following>`
+
+- `SingleZone` // Keyboards with only one zone
+- `ZonedKbLeft` // keyboard left
+- `ZonedKbLeftMid` // keyboard left-middle
+- `ZonedKbRightMid` // etc
+- `ZonedKbRight`
+- `LightbarRight`
+- `LightbarRightCorner`
+- `LightbarRightBottom`
+- `LightbarLeftBottom`
+- `LightbarLeftCorner`
+- `LightbarLeft`
+
+Single zone example:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            DoomFlicker((
+                led: SingleZone,
+                start_colour: (200, 40, 5),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: true,
+    ),
+)
+```
+
+At the moment there are only three effects available as shown in the example. More will come in the future
+but this may take me some time.
+
 #### Config options: AniMe
 
 `~/.config/rog/rog-user.cfg` contains a setting `"active_anime": "<FILENAME>"` where `<FILENAME>` is the name of the AniMe config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "anime-doom"`
@@ -158,6 +242,7 @@ Each object in the array can be one of:
 ##### AsusAnimation
 
 `AsusAnimation` is specifically for running the gif files that Armory Crate comes with. `asusctl` includes all of these in `/usr/share/asusd/anime/asus/`
+
 ```json
       "AsusAnimation": {
         "file": "<FILE_PATH>",
@@ -180,7 +265,7 @@ Virtually the same as `AsusAnimation` but for png files, typically created in th
 
 ##### ImageAnimation
 
-`ImageAnimation` can play *any* gif of any size.
+`ImageAnimation` can play _any_ gif of any size.
 
 ```json
       "ImageAnimation": {
@@ -239,6 +324,7 @@ Must be full path: `"/usr/share/asusd/anime/asus/gaming/Controller.gif"` or `/ho
 **<FLOAT>**
 
 A number from 0.0-1.0.
+
 - `brightness`: If it is brightness it is combined with the system daemon global brightness
 - `scale`: 1.0 is the original size with lower number shrinking, larger growing
 - `angle`: Rotation angle in radians
@@ -247,6 +333,7 @@ A number from 0.0-1.0.
 **<TIME>**
 
 Time is the length of time to run the gif for:
+
 ```json
         "time": {
           "Time": {
@@ -255,17 +342,23 @@ Time is the length of time to run the gif for:
           }
         },
 ```
+
 A cycle is how many gif loops to run:
+
 ```json
         "time": {
           "Cycles": 2
         },
 ```
+
 `Infinite` means that this gif will never end:
+
 ```json
         "time": "Infinite",
 ```
+
 `Fade` allows an image or gif to fade in and out, and remain at max brightness to n time:
+
 ```json
         "time": {
           "Fade": {
@@ -284,6 +377,7 @@ A cycle is how many gif loops to run:
           }
         },
 ```
+
 `show_for` can be `null`, if it is `null` then the `show_for` becomes `gif_time_length - fade_in - fade_out`.
 This is period for which the gif or image will be max brightness (as set).
 
@@ -293,7 +387,7 @@ A plain non-float integer.
 
 ## asusctl
 
-`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. I can be used in any place a terminal app can be used.
+`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. It can be used in any place a terminal app can be used.
 
 This program will query `asusd` for the `Support` level of the laptop and show or hide options according to this support level.
 
@@ -324,26 +418,19 @@ asusctl <command> <subcommand> --help
 
 To switch to next/previous Aura modes you will need to bind both the aura keys (if available) to one of:
 **Next**
+
 ```
-asusctl led-mode -n
+asusctl aura -n
 ```
+
 **Previous**
+
 ```
-asusctl led-mode -p
+asusctl aura -p
 ```
 
 To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profile -n`.
 
-## User NOTIFICATIONS via dbus
-
-If you have a notifications handler set up, or are using KDE or Gnome then you
-can enable the user service to get basic notifications when something changes.
-
-```
-systemctl --user enable asus-notify.service
-systemctl --user start asus-notify.service
-```
-
 # License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)
@@ -356,4 +443,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

@@ -1,4 +1,4 @@
-VERSION := $(shell grep -Pm1 'version = "(\d.\d.\d)"' daemon/Cargo.toml | cut -d'"' -f2)
+VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d+.\d+.\d+.*)"' Cargo.toml | cut -d'"' -f2)
 
 INSTALL = install
 INSTALL_PROGRAM = ${INSTALL} -D -m 0755
@@ -11,18 +11,39 @@ datarootdir = $(prefix)/share
 libdir = $(exec_prefix)/lib
 zshcpl = $(datarootdir)/zsh/site-functions
 
+BIN_ROG := rog-control-center
 BIN_C := asusctl
 BIN_D := asusd
 BIN_U := asusd-user
-BIN_N := asus-notify
-LEDCFG := asusd-ledmodes.toml
+LEDCFG := aura_support.ron
+
+DESTDIR_REALPATH = $(shell realpath $(DESTDIR))
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
+STRIP_BINARIES ?= 0
+
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
 	ARGS += --release
 	TARGET = release
+else
+	ARGS += --profile dev
+	TARGET = debug
+endif
+
+X11 ?= 0
+ifeq ($(X11),1)
+	ARGS += --features "rog-control-center/x11"
+endif
+
+# Always use the versions in Cargo.lock by default
+ARGS += --locked
+
+# Allow optionally freezing the build to avoid any network access and enforce Cargo.lock strictly
+FROZEN ?= 0
+ifeq ($(FROZEN),1)
+	ARGS += --frozen
 endif
 
 VENDORED ?= 0
@@ -38,23 +59,45 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install:
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
-	$(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)"
+target/$(TARGET)/$(BIN_D): $(SRC)
+	$(MAKE) build
 
-	$(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"
+target/$(TARGET)/$(BIN_C): $(SRC)
+	$(MAKE) build
 
-	$(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"
+target/$(TARGET)/$(BIN_U): $(SRC)
+	$(MAKE) build
+
+target/$(TARGET)/$(BIN_ROG): $(SRC)
+	$(MAKE) build
+
+install-asusd: target/$(TARGET)/$(BIN_D)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
+
+install-asusctl: target/$(TARGET)/$(BIN_C)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+
+install-asusd_user: target/$(TARGET)/$(BIN_U)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+
+install-rog_gui: target/$(TARGET)/$(BIN_ROG)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+.PHONY: install-asusd install-asusctl install-asusd_user install-rog_gui
+
+install-program: install-asusd install-asusctl install-asusd_user install-rog_gui
+
+install-data-rog_gui:
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR_REALPATH)$(datarootdir)/rog-gui/layouts/{}" \;
 
 	$(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_blue.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_blue.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_red.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_orange.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_orange.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_white.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_white.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"
@@ -63,19 +106,36 @@ install:
 	$(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 rog-anime/data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+install-data-asusd:
+	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
+
+	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
+
+	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR_REALPATH)$(datarootdir)/asusd/{}" \;
+
+install-data-asusd_user:
+	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+
+.PHONY: install-data-asusd install-data-asusd_user
+
+install-data: install-data-asusd install-data-asusd_user install-data-rog_gui
+
+install: install-program install-data
+	$(INSTALL_DATA) "./LICENSE" "$(DESTDIR)$(datarootdir)/asusctl/LICENSE"
 
 uninstall:
+	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
 	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/99-$(BIN_D).rules"
 	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 	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"
@@ -85,9 +145,8 @@ uninstall:
 	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"
+	rm -rf "$(DESTDIR)$(datarootdir)/rog-gui"
 
 update:
 	cargo update
@@ -98,14 +157,29 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
+	rm -rf vendor
+	# Ensure cargo-vendor-filterer is installed (CI installs it already)
+	command -v cargo-vendor-filterer >/dev/null 2>&1 || cargo install --locked cargo-vendor-filterer
+	cargo vendor-filterer --all-features --platform x86_64-unknown-linux-gnu vendor
 	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
 	rm -rf vendor
 
+translate:
+	find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po
+
 build:
 ifeq ($(VENDORED),1)
+	cargo vendor
 	@echo "version = $(VERSION)"
 	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
+ifeq ($(STRIP_BINARIES),1)
+	strip -s ./target/$(TARGET)/$(BIN_C)
+	strip -s ./target/$(TARGET)/$(BIN_D)
+	strip -s ./target/$(TARGET)/$(BIN_U)
+	strip -s ./target/$(TARGET)/$(BIN_ROG)
+endif
 
-.PHONY: all clean distclean install uninstall update build
+
+.PHONY: all clean distclean install uninstall update build bindings

README.md

@@ -1,110 +1,173 @@
 # `asusctl` for ASUS ROG
 
-[![](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=4V2DEPS7K6APC) - [Asus Linux Website](https://asus-linux.org/)
+[![Become a Patron!](https://github.com/codebard/patron-button-and-widgets-by-codebard/blob/master/images/become_a_patron_button.png?raw=true)](https://www.patreon.com/bePatron?u=7602281) [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/V7V5CLU67) - [Asus Linux Website](https://asus-linux.org/)
+
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel or latest release.
 
 `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 patches required
+Now includes a GUI, `rog-control-center`.
 
-1. https://lkml.org/lkml/2021/8/20/232
-2. https://lkml.org/lkml/2021/8/18/1022
+## Kernel support
+
+Due to on-going driver work the minimum suggested kernel version is always **the latest*, as improvements and fixes are continuous.
+
+Support for some new features is not avilable unless you run a patched kernel with the work I am doing [in this github repo](https://github.com/flukejones/linux/tree/wip/ally-6.13). Use the linked branch, or `wip/ally-6.12`. Everything that is done here is upstreamed eventually (a long process).
+
+Z13 devices will need [these](https://lore.kernel.org/linux-input/20240416090402.31057-1-luke@ljones.dev/T/#t)
+
+## X11 support
+
+X11 is not supported at all, as in I will not help you with X11 issues if there are any due to limited time and it being unmaintained itself. You can however build `rog-control-center` with it enabled `cargo build --features "rog-control-center/x11"`.
 
 ## 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.
-2. Enable third-party apps to use the above with dbus methods
-3. To make the above as easy as possible for new users
-4. Respect the users resources: be small, light, and fast
+The main goal of this work is to provide a safe and easy to use abstraction over various laptop features via DBUS, and to provide some helpful defaults and other behaviour such as toggling throttle/profile on AC/battery change.
 
-Point 3 means that the list of supported distros is very narrow - fedora is explicitly
-supported, while Ubuntu and openSUSE are level-2 support. All other distros are *not*
-supported (while asusd might still run fine on them). For best support use fedora 32+ Workstation.
+1. Provide safe dbus interface
+2. Respect the users resources: be small, light, and fast
 
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
-a system-level daemon should.
+a system-level daemon should. Languages such as JS and python should never be used for system level daemons (please stop).
 
-**NOTICE:**
+## Keyboard LEDs
 
-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.
+The level of support for laptops is dependent on folks submitting data to include in [`./rog-aura/data/layouts/aura_support.ron`](./rog-aura/data/layouts/aura_support.ron), typically installed in `/usr/share/asusd/aura_support.ron`. This is because the controller used for keyboards and LEDs is used across many years and many laptop models, all with different firmware configurations - the only way to track this is with the file mentioned above. Why not just enable all by default? Because it confuses people.
+
+See the [rog-aura readme](./rog-aura/README.md) for more details.
 
 ## Discord
 
-[Discord server link](https://discord.gg/4ZKGd7Un5t)
+[![Discord](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/B8GftRW2Hd)
 
 ## SUPPORTED LAPTOPS
 
 Most ASUS gaming laptops that have a USB keyboard. If `lsusb` shows something similar
 to this:
 
-```
+```plain
 Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
 
+or
+
+```plain
+Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
+```
+
 then it may work without tweaks. Technically all other functions except the LED
-and AniMe parts should work regardless of your latop make. Eventually this project
-will probably suffer another rename once it becomes generic enough to do so.
+and AniMe parts should work regardless of your latop make.
 
 ## Implemented
 
-- [X] System daemon
-- [X] User notifications daemon
-- [X] Setting/modifying built-in LED modes
-- [X] Per-key LED setting
-- [X] Fancy LED modes (See examples) (currently being reworked)
-- [X] Saving settings for reload
-- [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. 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)
+The list is a bit outdated as many features have been enabled in the Linux kernel with upstream patches and then supported in asusctl suite.
 
-# BUILDING
+- [x] System daemon
+- [x] GUI app (includes tray and notifications)
+- [x] Setting/modifying built-in LED modes
+- [x] Per-key LED setting
+- [x] Fancy LED modes (See examples) (currently being reworked)
+- [x] AniMatrix display on G14 and M16 models that include it
+- [x] Set battery charge limit (with kernel supporting this)
+- [x] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
+- [x] Toggle bios setting for boot/POST sound
+- [x] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
-Requirements are rust >= 1.47 installed from rustup.io if the distro provided version is too old, and `make`.
+## GUI
 
-**Ubuntu:** `apt install libclang-dev libudev-dev`
+A gui is now in the repo - ROG Control Center. At this time it is still a WIP, but it has almost all features in place already.
 
-**fedora:** `dnf install clang-devel systemd-devel`
+**NOTE**: Xorg is not supported.
+
+## BUILDING
+
+Rust and cargo are required, they can be installed from [rustup.rs](https://rustup.rs/).
+
+Distro packaging should work with the stable toolchain. If your distro does not provide a recent Rust toolchain, install rustup and use the stable toolchain.
+
+**fedora:**
+
+```sh
+dnf install cmake clang-devel  libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
+make
+sudo make install
+```
+
+**openSUSE:**
+
+Works with KDE Plasma (without GTK packages)
+
+```sh
+zypper in -t pattern devel_basis
+zypper in rustup make cmake clang-devel libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
+make
+sudo make install
+```
+
+**Debian(unsuported):**
+
+officially unsuported,but you can still try and test it by yourself(some features may not be available).
+
+```sh
+sudo apt install libclang-dev libudev-dev libfontconfig-dev build-essential cmake libxkbcommon-dev
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+make
+sudo make install
+```
+
+**Ubuntu, Popos (unsuported):**
+
+```sh
+sudo apt install make cargo gcc pkg-config openssl libasound2-dev cmake build-essential python3 libfreetype6-dev libexpat1-dev libxcb-composite0-dev libssl-dev libx11-dev libfontconfig1-dev curl libclang-dev libudev-dev checkinstall libseat-dev libinput-dev libxkbcommon-dev libgbm-dev
+
+make
+sudo make install
+```
 
 ## Installing
 
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/) for the latest versions of Fedora, Ubuntu, and openSUSE.
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
 
-### Ubuntu
-
-    sudo su -c "echo 'deb https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/ /' > /etc/apt/sources.list.d/luke_nukem.list"
-    curl -fsSL https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/Release.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/home_luke_nukem.gpg > /dev/null
-    sudo apt-get update
-    sudo apt-get install asusctl dkms-hid-asus-rog
-
-
----
-
-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.
 
+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.
+
+## Upgrading
+
 If you are upgrading from a previous installed version, you will need to restart the service or reboot.
 
+```sh
+systemctl daemon-reload && systemctl restart asusd
 ```
-$ 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.
 
 ## Uninstalling
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
-# OTHER
+## Contributing
 
-## Supporting more laptops
+See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
+
+Generation of the bindings with `make bindings` requires `typeshare` to be installed.
+
+Dbus introsepction XML requires with `make introspection` requires `anime_sim` to be running before starting `asusd`.
+
+## OTHER
+
+### AniMe Matrix simulator
+
+A simulator using SDL2 can be built using `cargo build --package rog_simulators` and run with `./target/debug/anime_sim`. Once started `asusd` will need restarting to pick it up. If running this sim on a laptop _with_ the display, the simulated display will be used instead of the physical display.
+
+### Supporting more laptops
 
 Please file a support request.
 
-# License & Trademarks
+## License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)
 

asus-notify/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "asus-notify"
-version = "3.0.2"
-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 = "^1.9"
-# serialisation
-serde_json = "^1.0"
-rog_dbus = { path = "../rog-dbus" }
-rog_aura = { path = "../rog-aura" }
-rog_supported = { path = "../rog-supported" }
-rog_profiles = { path = "../rog-profiles" }
-
-[dependencies.notify-rust]
-version = "^4.3"
-default-features = false
-features = ["z"]

asus-notify/src/main.rs

@@ -1,104 +0,0 @@
-use notify_rust::{Hint, Notification, NotificationHandle};
-use rog_aura::AuraEffect;
-use rog_dbus::{DbusProxies, Signals};
-use rog_profiles::Profile;
-use std::error::Error;
-use std::thread::sleep;
-use std::time::Duration;
-
-const NOTIF_HEADER: &str = "ROG Control";
-
-macro_rules! notify {
-    ($notifier:ident, $last_notif:ident, $data:expr) => {
-        if let Some(notif) = $last_notif.take() {
-            notif.close();
-        }
-        if let Ok(x) = $notifier($data) {
-            $last_notif = Some(x);
-        }
-    };
-}
-
-macro_rules! base_notification {
-    ($body:expr) => {
-        Notification::new()
-            .summary(NOTIF_HEADER)
-            .body($body)
-            .timeout(2000)
-            .show()
-    };
-}
-
-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);
-        }
-    }
-}
-
-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 {}",
-        ledmode.mode_name()
-    ))
-}
-
-fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("Battery charge limit changed to {}", limit))
-}
-

asusctl/Cargo.toml

@@ -1,26 +1,41 @@
 [package]
 name = "asusctl"
-version = "4.0.5"
-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
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
 
 [dependencies]
-zbus = "^1.9.1"
 rog_anime = { path = "../rog-anime" }
+rog_scsi = { path = "../rog-scsi" }
+rog_slash = { path = "../rog-slash" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
-rog_supported = { path = "../rog-supported" }
-daemon = { path = "../daemon" }
-gumdrop = "^0.8"
-toml = "^0.5.8"
+rog_platform = { path = "../rog-platform" }
+dmi_id = { path = "../dmi-id" }
 
-sysfs-class = "^0.1.2"
+log.workspace = true
+env_logger.workspace = true
+
+ron.workspace = true
+gumdrop.workspace = true
+zbus.workspace = true
 
 [dev-dependencies]
-tinybmp = "^0.2.3"
-glam = "0.14.0"
 rog_dbus = { path = "../rog-dbus" }
-gif = "^0.11.2"
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+An utility for Linux to control many aspects of various ASUS laptops
+but can also be used with non-asus laptops with reduced features."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusctl", "usr/bin/", "755"],
+]

asusctl/examples/anime-diag-png.rs

@@ -1,26 +1,34 @@
-use std::{env, error::Error, path::Path, process::exit};
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 3 {
         println!("Usage: <filepath> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.8");
         exit(-1);
     }
 
-    let matrix =
-        AnimeDiagonal::from_png(Path::new(&args[1]), None, args[2].parse::<f32>().unwrap())?;
+    let matrix = AnimeDiagonal::from_png(
+        Path::new(&args[1]),
+        None,
+        args[2].parse::<f32>().unwrap(),
+        AnimeType::GA401,
+    )?;
 
-    client
-        .proxies()
-        .anime()
-        .write(<AnimeDataBuffer>::from(&matrix))
-        .unwrap();
+    let anime_type = get_anime_type();
+
+    proxy.write(matrix.into_data_buffer(anime_type)?).unwrap();
 
     Ok(())
 }

asusctl/examples/anime-diag.rs

@@ -1,7 +1,10 @@
-use std::{thread::sleep, time::Duration};
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -9,24 +12,27 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
     for step in (2..50).rev() {
-        let mut matrix = AnimeDiagonal::new(None);
-        for c in (0..60).into_iter().step_by(step) {
+        let mut matrix = AnimeDiagonal::new(AnimeType::GA401, None);
+        for c in (0..60).step_by(step) {
             for i in matrix.get_mut().iter_mut() {
                 i[c] = 50;
             }
         }
 
-        for c in (0..35).into_iter().step_by(step) {
-            for i in matrix.get_mut()[c].iter_mut() {
+        for c in (0..35).step_by(step) {
+            for i in &mut matrix.get_mut()[c] {
                 *i = 50;
             }
         }
 
-        let m = <AnimeDataBuffer>::from(&matrix);
-        client.proxies().anime().write(m).unwrap();
+        let anime_type = get_anime_type();
+        proxy
+            .write(matrix.into_data_buffer(anime_type).unwrap())
+            .unwrap();
         sleep(Duration::from_millis(300));
     }
 }

asusctl/examples/anime-gif.rs

@@ -1,12 +1,17 @@
-use std::{env, path::Path, thread::sleep};
+use std::env;
+use std::path::Path;
+use std::thread::sleep;
 
+use rog_anime::usb::get_anime_type;
 use rog_anime::{ActionData, ActionLoader, Sequences};
-use rog_dbus::RogDbusClient;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 3 {
         println!("Please supply filepath and brightness");
         return;
@@ -14,7 +19,8 @@ fn main() {
 
     let path = Path::new(&args[1]);
     let brightness = args[2].parse::<f32>().unwrap();
-    let mut seq = Sequences::new();
+    let anime_type = get_anime_type();
+    let mut seq = Sequences::new(anime_type);
     seq.insert(
         0,
         &ActionLoader::AsusAnimation {
@@ -29,11 +35,7 @@ fn main() {
         for action in seq.iter() {
             if let ActionData::Animation(frames) = action {
                 for frame in frames.frames() {
-                    client
-                        .proxies()
-                        .anime()
-                        .write(frame.frame().clone())
-                        .unwrap();
+                    proxy.write(frame.frame().clone()).unwrap();
                     sleep(frame.delay());
                 }
             }

asusctl/examples/anime-grid.rs

@@ -1,5 +1,9 @@
+use std::convert::TryFrom;
+
+use rog_anime::usb::get_anime_type;
 use rog_anime::{AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClient;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -7,15 +11,17 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
-    let mut matrix = AnimeGrid::new(None);
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let anime_type = get_anime_type();
+    let mut matrix = AnimeGrid::new(anime_type);
     let tmp = matrix.get_mut();
 
     let mut i = 0;
     for (y, row) in tmp.iter_mut().enumerate() {
         if y % 2 == 0 && i + 1 != row.len() - 1 {
             i += 1;
-            dbg!(i);
         }
         row[row.len() - i] = 0x22;
         if i > 5 {
@@ -38,7 +44,7 @@ fn main() {
         }
     }
 
-    let matrix = <AnimeDataBuffer>::from(matrix);
+    let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
 
-    client.proxies().anime().write(matrix).unwrap();
+    proxy.write(matrix).unwrap();
 }

asusctl/examples/anime-outline.rs

@@ -1,129 +1,133 @@
+use rog_anime::usb::get_anime_type;
 use rog_anime::AnimeDataBuffer;
-use rog_dbus::RogDbusClient;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
-    let mut matrix = AnimeDataBuffer::new();
-    matrix.get_mut()[1] = 100; // start = 1
-    for n in matrix.get_mut()[2..32].iter_mut() {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+    let anime_type = get_anime_type();
+    let mut matrix = AnimeDataBuffer::new(anime_type);
+    matrix.data_mut()[1] = 100; // start = 1
+    for n in matrix.data_mut()[2..32].iter_mut() {
         *n = 250;
     }
-    matrix.get_mut()[32] = 100; // end
-    matrix.get_mut()[34] = 100; // start x = 0
-    matrix.get_mut()[66] = 100; // end
-    matrix.get_mut()[69] = 100; // start x = 1
-    matrix.get_mut()[101] = 100; // end
-    matrix.get_mut()[102] = 100; // start
-    matrix.get_mut()[134] = 100; // end
-    matrix.get_mut()[137] = 100; // start
-    matrix.get_mut()[169] = 100; // end
-    matrix.get_mut()[170] = 100; // start
-    matrix.get_mut()[202] = 100; // end
-    matrix.get_mut()[204] = 100; // start
-    matrix.get_mut()[236] = 100; // end
-    matrix.get_mut()[237] = 100; // start
-    matrix.get_mut()[268] = 100; // end
-    matrix.get_mut()[270] = 100; // start
-    matrix.get_mut()[301] = 100; // end
-    matrix.get_mut()[302] = 100; // start
-    matrix.get_mut()[332] = 100; // end
-    matrix.get_mut()[334] = 100; // start
-    matrix.get_mut()[364] = 100; // end
-    matrix.get_mut()[365] = 100; // start
-    matrix.get_mut()[394] = 100; // end
-    matrix.get_mut()[396] = 100; // start
-    matrix.get_mut()[425] = 100; // end
-    matrix.get_mut()[426] = 100; // start
-    matrix.get_mut()[454] = 100; // end
-    matrix.get_mut()[456] = 100; // start
-    matrix.get_mut()[484] = 100; // end
-    matrix.get_mut()[485] = 100; // start
-    matrix.get_mut()[512] = 100; // end
-    matrix.get_mut()[514] = 100; // start
-    matrix.get_mut()[541] = 100; // end
-    matrix.get_mut()[542] = 100; // start
-    matrix.get_mut()[568] = 100; // end
-    matrix.get_mut()[570] = 100; // start
-    matrix.get_mut()[596] = 100; // end
-    matrix.get_mut()[597] = 100; // start
-    matrix.get_mut()[622] = 100; // end
-    matrix.get_mut()[624] = 100; // start
-    matrix.get_mut()[649] = 100; // end
-    matrix.get_mut()[650] = 100; // start
-    matrix.get_mut()[674] = 100; // end
-    matrix.get_mut()[676] = 100; // start
-    matrix.get_mut()[700] = 100; // end
-    matrix.get_mut()[701] = 100; // start
-    matrix.get_mut()[724] = 100; // end
-    matrix.get_mut()[726] = 100; // start
-    matrix.get_mut()[749] = 100; // end
-    matrix.get_mut()[750] = 100; // start
-    matrix.get_mut()[772] = 100; // end
-    matrix.get_mut()[774] = 100; // start
-    matrix.get_mut()[796] = 100; // end
-    matrix.get_mut()[797] = 100; // start
-    matrix.get_mut()[818] = 100; // end
-    matrix.get_mut()[820] = 100; // start
-    matrix.get_mut()[841] = 100; // end
-    matrix.get_mut()[842] = 100; // start
-    matrix.get_mut()[862] = 100; // end
-    matrix.get_mut()[864] = 100; // start
-    matrix.get_mut()[884] = 100; // end
-    matrix.get_mut()[885] = 100; // start
-    matrix.get_mut()[904] = 100; // end
-    matrix.get_mut()[906] = 100; // start
-    matrix.get_mut()[925] = 100; // end
-    matrix.get_mut()[926] = 100; // start
-    matrix.get_mut()[944] = 100; // end
-    matrix.get_mut()[946] = 100; // start
-    matrix.get_mut()[964] = 100; // end
-    matrix.get_mut()[965] = 100; // start
-    matrix.get_mut()[982] = 100; // end
-    matrix.get_mut()[984] = 100; // start
-    matrix.get_mut()[1001] = 100; // end
-    matrix.get_mut()[1002] = 100; // start
-    matrix.get_mut()[1018] = 100; // end
-    matrix.get_mut()[1020] = 100; // start
-    matrix.get_mut()[1036] = 100; // end
-    matrix.get_mut()[1037] = 100; // start
-    matrix.get_mut()[1052] = 100; // end
-    matrix.get_mut()[1054] = 100; // start
-    matrix.get_mut()[1069] = 100; // end
-    matrix.get_mut()[1070] = 100; // start
-    matrix.get_mut()[1084] = 100; // end
-    matrix.get_mut()[1086] = 100; // start
-    matrix.get_mut()[1100] = 100; // end
-    matrix.get_mut()[1101] = 100; // start
-    matrix.get_mut()[1114] = 100; // end
-    matrix.get_mut()[1116] = 100; // start
-    matrix.get_mut()[1129] = 100; // end
-    matrix.get_mut()[1130] = 100; // start
-    matrix.get_mut()[1142] = 100; // end
-    matrix.get_mut()[1144] = 100; // start
-    matrix.get_mut()[1156] = 100; // end
-    matrix.get_mut()[1157] = 100; // start
-    matrix.get_mut()[1168] = 100; // end
-    matrix.get_mut()[1170] = 100; // start
-    matrix.get_mut()[1181] = 100; // end
-    matrix.get_mut()[1182] = 100; // start
-    matrix.get_mut()[1192] = 100; // end
-    matrix.get_mut()[1194] = 100; // start
-    matrix.get_mut()[1204] = 100; // end
-    matrix.get_mut()[1205] = 100; // start
-    matrix.get_mut()[1214] = 100; // end
-    matrix.get_mut()[1216] = 100; // start
-    matrix.get_mut()[1225] = 100; // end
-    matrix.get_mut()[1226] = 100; // start
-    matrix.get_mut()[1234] = 100; // end
-    matrix.get_mut()[1236] = 100; // start
-    for n in matrix.get_mut()[1237..1244].iter_mut() {
+    matrix.data_mut()[32] = 100; // end
+    matrix.data_mut()[34] = 100; // start x = 0
+    matrix.data_mut()[66] = 100; // end
+    matrix.data_mut()[69] = 100; // start x = 1
+    matrix.data_mut()[101] = 100; // end
+    matrix.data_mut()[102] = 100; // start
+    matrix.data_mut()[134] = 100; // end
+    matrix.data_mut()[137] = 100; // start
+    matrix.data_mut()[169] = 100; // end
+    matrix.data_mut()[170] = 100; // start
+    matrix.data_mut()[202] = 100; // end
+    matrix.data_mut()[204] = 100; // start
+    matrix.data_mut()[236] = 100; // end
+    matrix.data_mut()[237] = 100; // start
+    matrix.data_mut()[268] = 100; // end
+    matrix.data_mut()[270] = 100; // start
+    matrix.data_mut()[301] = 100; // end
+    matrix.data_mut()[302] = 100; // start
+    matrix.data_mut()[332] = 100; // end
+    matrix.data_mut()[334] = 100; // start
+    matrix.data_mut()[364] = 100; // end
+    matrix.data_mut()[365] = 100; // start
+    matrix.data_mut()[394] = 100; // end
+    matrix.data_mut()[396] = 100; // start
+    matrix.data_mut()[425] = 100; // end
+    matrix.data_mut()[426] = 100; // start
+    matrix.data_mut()[454] = 100; // end
+    matrix.data_mut()[456] = 100; // start
+    matrix.data_mut()[484] = 100; // end
+    matrix.data_mut()[485] = 100; // start
+    matrix.data_mut()[512] = 100; // end
+    matrix.data_mut()[514] = 100; // start
+    matrix.data_mut()[541] = 100; // end
+    matrix.data_mut()[542] = 100; // start
+    matrix.data_mut()[568] = 100; // end
+    matrix.data_mut()[570] = 100; // start
+    matrix.data_mut()[596] = 100; // end
+    matrix.data_mut()[597] = 100; // start
+    matrix.data_mut()[622] = 100; // end
+    matrix.data_mut()[624] = 100; // start
+    matrix.data_mut()[649] = 100; // end
+    matrix.data_mut()[650] = 100; // start
+    matrix.data_mut()[674] = 100; // end
+    matrix.data_mut()[676] = 100; // start
+    matrix.data_mut()[700] = 100; // end
+    matrix.data_mut()[701] = 100; // start
+    matrix.data_mut()[724] = 100; // end
+    matrix.data_mut()[726] = 100; // start
+    matrix.data_mut()[749] = 100; // end
+    matrix.data_mut()[750] = 100; // start
+    matrix.data_mut()[772] = 100; // end
+    matrix.data_mut()[774] = 100; // start
+    matrix.data_mut()[796] = 100; // end
+    matrix.data_mut()[797] = 100; // start
+    matrix.data_mut()[818] = 100; // end
+    matrix.data_mut()[820] = 100; // start
+    matrix.data_mut()[841] = 100; // end
+    matrix.data_mut()[842] = 100; // start
+    matrix.data_mut()[862] = 100; // end
+    matrix.data_mut()[864] = 100; // start
+    matrix.data_mut()[884] = 100; // end
+    matrix.data_mut()[885] = 100; // start
+    matrix.data_mut()[904] = 100; // end
+    matrix.data_mut()[906] = 100; // start
+    matrix.data_mut()[925] = 100; // end
+    matrix.data_mut()[926] = 100; // start
+    matrix.data_mut()[944] = 100; // end
+    matrix.data_mut()[946] = 100; // start
+    matrix.data_mut()[964] = 100; // end
+    matrix.data_mut()[965] = 100; // start
+    matrix.data_mut()[982] = 100; // end
+    matrix.data_mut()[984] = 100; // start
+    matrix.data_mut()[1001] = 100; // end
+    matrix.data_mut()[1002] = 100; // start
+    matrix.data_mut()[1018] = 100; // end
+    matrix.data_mut()[1020] = 100; // start
+    matrix.data_mut()[1036] = 100; // end
+    matrix.data_mut()[1037] = 100; // start
+    matrix.data_mut()[1052] = 100; // end
+    matrix.data_mut()[1054] = 100; // start
+    matrix.data_mut()[1069] = 100; // end
+    matrix.data_mut()[1070] = 100; // start
+    matrix.data_mut()[1084] = 100; // end
+    matrix.data_mut()[1086] = 100; // start
+    matrix.data_mut()[1100] = 100; // end
+    matrix.data_mut()[1101] = 100; // start
+    matrix.data_mut()[1114] = 100; // end
+    matrix.data_mut()[1116] = 100; // start
+    matrix.data_mut()[1129] = 100; // end
+    matrix.data_mut()[1130] = 100; // start
+    matrix.data_mut()[1142] = 100; // end
+    matrix.data_mut()[1144] = 100; // start
+    matrix.data_mut()[1156] = 100; // end
+    matrix.data_mut()[1157] = 100; // start
+    matrix.data_mut()[1168] = 100; // end
+    matrix.data_mut()[1170] = 100; // start
+    matrix.data_mut()[1181] = 100; // end
+    matrix.data_mut()[1182] = 100; // start
+    matrix.data_mut()[1192] = 100; // end
+    matrix.data_mut()[1194] = 100; // start
+    matrix.data_mut()[1204] = 100; // end
+    matrix.data_mut()[1205] = 100; // start
+    matrix.data_mut()[1214] = 100; // end
+    matrix.data_mut()[1216] = 100; // start
+    matrix.data_mut()[1225] = 100; // end
+    matrix.data_mut()[1226] = 100; // start
+    matrix.data_mut()[1234] = 100; // end
+    matrix.data_mut()[1236] = 100; // start
+    for n in matrix.data_mut()[1237..1244].iter_mut() {
         *n = 250;
     }
-    matrix.get_mut()[1244] = 100; // end
+    matrix.data_mut()[1244] = 100; // end
     println!("{:?}", &matrix);
 
-    client.proxies().anime().write(matrix).unwrap();
+    proxy.write(matrix).unwrap();
 }

asusctl/examples/anime-png.rs

@@ -1,20 +1,26 @@
-use std::{env, error::Error, path::Path, process::exit};
+use std::convert::TryFrom;
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 7 {
         println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");
         exit(-1);
     }
 
+    let anime_type = get_anime_type();
     let matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -24,13 +30,10 @@ fn main() -> Result<(), Box<dyn Error>> {
             args[5].parse::<f32>().unwrap(),
         ),
         args[6].parse::<f32>().unwrap(),
+        anime_type,
     )?;
 
-    client
-        .proxies()
-        .anime()
-        .write(<AnimeDataBuffer>::from(&matrix))
-        .unwrap();
+    proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
 
     Ok(())
 }

asusctl/examples/anime-spinning.rs

@@ -1,22 +1,29 @@
-use std::{
-    env, error::Error, f32::consts::PI, path::Path, process::exit, thread::sleep, time::Duration,
-};
+use std::convert::TryFrom;
+use std::env;
+use std::error::Error;
+use std::f32::consts::PI;
+use std::path::Path;
+use std::process::exit;
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 7 {
         println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");
         exit(-1);
     }
 
+    let anime_type = get_anime_type();
     let mut matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -26,20 +33,17 @@ fn main() -> Result<(), Box<dyn Error>> {
             args[5].parse::<f32>().unwrap(),
         ),
         args[6].parse::<f32>().unwrap(),
+        anime_type,
     )?;
 
     loop {
         matrix.angle += 0.05;
         if matrix.angle > PI * 2.0 {
-            matrix.angle = 0.0
+            matrix.angle = 0.0;
         }
         matrix.update();
 
-        client
-            .proxies()
-            .anime()
-            .write(<AnimeDataBuffer>::from(&matrix))
-            .unwrap();
+        proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
         sleep(Duration::from_micros(500));
     }
 }

asusctl/examples/aura-rgb-ball.rs

@@ -1,94 +0,0 @@
-use rog_aura::{GX502Layout, Key, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
-use std::collections::LinkedList;
-
-#[derive(Debug, Clone)]
-struct Ball {
-    position: (i32, i32),
-    direction: (i32, i32),
-    trail: LinkedList<(i32, i32)>,
-}
-impl Ball {
-    fn new(x: i32, y: i32, trail_len: u32) -> Self {
-        let mut trail = LinkedList::new();
-        for _ in 1..=trail_len {
-            trail.push_back((x, y));
-        }
-
-        Ball {
-            position: (x, y),
-            direction: (1, 1),
-            trail,
-        }
-    }
-
-    #[allow(clippy::if_same_then_else)]
-    fn update(&mut self, key_map: &[[Key; 17]]) {
-        let pos = self.position;
-        let dir = self.direction;
-
-        if pos.0 + dir.0 > key_map[pos.1 as usize].len() as i32 - 1 || pos.0 + dir.0 < 0 {
-            self.direction.0 *= -1;
-        } else if key_map[(pos.1) as usize][(pos.0 + dir.0) as usize] == Key::None {
-            self.direction.0 *= -1;
-        }
-
-        if pos.1 + dir.1 > key_map.len() as i32 - 1 || pos.1 + dir.1 < 0 {
-            self.direction.1 *= -1;
-        } else if key_map[(pos.1 + dir.1) as usize][(pos.0) as usize] == Key::None {
-            self.direction.1 *= -1;
-        }
-
-        self.trail.pop_front();
-        self.trail.push_back(self.position);
-
-        self.position.0 += self.direction.0;
-        self.position.1 += self.direction.1;
-
-        if self.position.0 > key_map[self.position.1 as usize].len() as i32 {
-            self.position.0 = key_map[self.position.1 as usize].len() as i32 - 1;
-        }
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
-
-    let mut colours = KeyColourArray::new();
-
-    let layout = GX502Layout::default();
-
-    let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
-
-    dbus.proxies().led().init_effect()?;
-
-    let rows = layout.get_rows();
-    loop {
-        for (n, ball) in balls.iter_mut().enumerate() {
-            ball.update(rows);
-            for (i, pos) in ball.trail.iter().enumerate() {
-                if let Some(c) = colours.key(rows[pos.1 as usize][pos.0 as usize]) {
-                    *c.0 = 0;
-                    *c.1 = 0;
-                    *c.2 = 0;
-                    if n == 0 {
-                        *c.0 = i as u8 * (255 / ball.trail.len() as u8);
-                    } else if n == 1 {
-                        *c.1 = i as u8 * (255 / ball.trail.len() as u8);
-                    } else if n == 2 {
-                        *c.2 = i as u8 * (255 / ball.trail.len() as u8);
-                    }
-                };
-            }
-
-            if let Some(c) = colours.key(rows[ball.position.1 as usize][ball.position.0 as usize]) {
-                *c.0 = 255;
-                *c.1 = 255;
-                *c.2 = 255;
-            };
-        }
-        dbus.proxies().led().set_per_key(&colours)?;
-
-        std::thread::sleep(std::time::Duration::from_millis(10));
-    }
-}

asusctl/examples/aura-rgb-ball.rs-

@@ -0,0 +1,113 @@
+//! Very bad rushed example. The better way to do this would be to have
+//! the balles move on their own square grid, then translate that to the
+//! key layout via shape by pitch etc.
+use rog_aura::{
+    layouts::{KeyLayout, KeyRow},
+    KeyColourArray,
+};
+use rog_dbus::RogDbusClientBlocking;
+use std::collections::VecDeque;
+
+#[derive(Debug, Clone)]
+struct Ball {
+    position: (f32, f32),
+    direction: (f32, f32),
+    trail: VecDeque<(f32, f32)>,
+}
+impl Ball {
+    fn new(x: f32, y: f32, trail_len: u32) -> Self {
+        let mut trail = VecDeque::new();
+        for _ in 1..=trail_len {
+            trail.push_back((x, y));
+        }
+
+        Ball {
+            position: (x, y),
+            direction: (1.0, 1.0),
+            trail,
+        }
+    }
+
+    #[allow(clippy::if_same_then_else)]
+    fn update(&mut self, key_map: &[KeyRow]) {
+        self.position.0 += self.direction.0;
+        self.position.1 += self.direction.1;
+
+        if self.position.1.abs() as usize >= key_map.len() {
+            self.direction.1 *= -1.0;
+            self.position.1 += self.direction.1;
+            self.direction.0 *= -1.0;
+            self.position.0 += self.direction.0;
+        }
+        if self.position.0.abs() as usize >= key_map[self.position.1.abs() as usize].row_ref().len()
+        {
+            self.direction.1 *= -1.0;
+            self.position.1 += self.direction.1;
+        }
+        if self.position.0 as usize >= key_map[self.position.1.abs() as usize].row_ref().len() {
+            self.direction.0 *= -1.0;
+            self.position.0 += self.direction.0;
+        }
+
+        let pos = self.position;
+
+        if pos.1 == key_map[pos.1.abs() as usize].row_ref().len() as f32 - 1.0 || pos.1 <= 0.0 {
+            self.direction.0 *= -1.0;
+        } else if key_map[(pos.1) as usize].row_ref()[(pos.0) as usize].is_placeholder() {
+            self.direction.0 *= -1.0;
+        }
+
+        if pos.0 == key_map.len() as f32 - 1.0 || pos.0 <= 0.0 {
+            self.direction.1 *= -1.0;
+        } else if key_map[(pos.1) as usize].row_ref()[(pos.0) as usize].is_placeholder() {
+            self.direction.1 *= -1.0;
+        }
+
+        self.trail.pop_front();
+        self.trail.push_back(self.position);
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = RogDbusClientBlocking::new()?;
+
+    let mut colours = KeyColourArray::new();
+    let layout = KeyLayout::gx502_layout();
+
+    let mut balls = [Ball::new(2.0, 1.0, 12), Ball::new(5.0, 2.0, 12)];
+    // let mut balls = [Ball::new(2, 1, 12)];
+
+    loop {
+        for (n, ball) in balls.iter_mut().enumerate() {
+            ball.update(layout.rows_ref());
+            for (i, pos) in ball.trail.iter().enumerate() {
+                if let Some(c) = colours
+                    .rgb_for_key(layout.rows_ref()[pos.1.abs() as usize].row_ref()[pos.0 as usize])
+                {
+                    c[0] = 0;
+                    c[1] = 0;
+                    c[2] = 0;
+                    if n == 0 {
+                        c[0] = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 1 {
+                        c[1] = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 2 {
+                        c[2] = i as u8 * (255 / ball.trail.len() as u8);
+                    }
+                };
+            }
+
+            if let Some(c) = colours.rgb_for_key(
+                layout.rows_ref()[ball.position.1.abs() as usize].row_ref()
+                    [ball.position.0 as usize],
+            ) {
+                c[0] = 255;
+                c[1] = 255;
+                c[2] = 255;
+            };
+        }
+        dbus.proxies().led().direct_addressing_raw(colours.get())?;
+
+        std::thread::sleep(std::time::Duration::from_millis(150));
+    }
+}

asusctl/examples/aura-rgb-comet.rs

@@ -1,28 +0,0 @@
-use rog_aura::{GX502Layout, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
-
-    let layout = GX502Layout::default();
-
-    dbus.proxies().led().init_effect()?;
-    let rows = layout.get_rows();
-
-    let mut column = 0;
-    loop {
-        let mut key_colours = KeyColourArray::new();
-        for row in rows {
-            if let Some(c) = key_colours.key(row[column as usize]) {
-                *c.0 = 255;
-            };
-        }
-        if column == rows[0].len() - 1 {
-            column = 0
-        } else {
-            column += 1;
-        }
-
-        dbus.proxies().led().set_per_key(&key_colours)?;
-    }
-}

asusctl/examples/aura-rgb-iterate-keys.rs

@@ -1,54 +0,0 @@
-use rog_aura::{GX502Layout, Key, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-    let layout = GX502Layout::default();
-
-    dbus.proxies().led().init_effect()?;
-    let rows = layout.get_rows();
-    loop {
-        for (r, row) in rows.iter().enumerate() {
-            for (k, key) in row.iter().enumerate() {
-                if let Some(c) = key_colours.key(*key) {
-                    *c.0 = 255;
-                };
-                // Last key of previous row
-                if k == 0 {
-                    if r == 0 {
-                        let k = &rows[rows.len() - 1][rows[rows.len() - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
-                        };
-                    } else {
-                        let k = &rows[r - 1][rows[r - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
-                        };
-                    }
-                } else {
-                    let k = &rows[r][k - 1];
-                    if let Some(c) = key_colours.key(*k) {
-                        *c.0 = 0;
-                    };
-                }
-                if let Some(c) = key_colours.key(Key::Up) {
-                    *c.0 = 255;
-                };
-                *key_colours.key(Key::Left).unwrap().0 = 255;
-                *key_colours.key(Key::Right).unwrap().0 = 255;
-                *key_colours.key(Key::Down).unwrap().0 = 255;
-
-                *key_colours.key(Key::W).unwrap().0 = 255;
-                *key_colours.key(Key::A).unwrap().0 = 255;
-                *key_colours.key(Key::S).unwrap().0 = 255;
-                *key_colours.key(Key::D).unwrap().0 = 255;
-
-                dbus.proxies().led().set_per_key(&key_colours)?;
-                std::thread::sleep(std::time::Duration::from_millis(100));
-            }
-        }
-    }
-}

asusctl/examples/aura-rgb-per-key-effect-2.rs

@@ -1,31 +0,0 @@
-use rog_aura::{Key, KeyColourArray};
-use rog_dbus::RogDbusClient;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-
-    dbus.proxies().led().init_effect()?;
-    loop {
-        let count = 49;
-        for _ in 0..count {
-            *key_colours.key(Key::Rog).unwrap().0 += 5;
-            *key_colours.key(Key::L).unwrap().0 += 5;
-            *key_colours.key(Key::I).unwrap().0 += 5;
-            *key_colours.key(Key::N).unwrap().0 += 5;
-            *key_colours.key(Key::U).unwrap().0 += 5;
-            *key_colours.key(Key::X).unwrap().0 += 5;
-            dbus.proxies().led().set_per_key(&key_colours)?;
-        }
-        for _ in 0..count {
-            *key_colours.key(Key::Rog).unwrap().0 -= 5;
-            *key_colours.key(Key::L).unwrap().0 -= 5;
-            *key_colours.key(Key::I).unwrap().0 -= 5;
-            *key_colours.key(Key::N).unwrap().0 -= 5;
-            *key_colours.key(Key::U).unwrap().0 -= 5;
-            *key_colours.key(Key::X).unwrap().0 -= 5;
-            dbus.proxies().led().set_per_key(&key_colours)?;
-        }
-    }
-}

asusctl/examples/aura-rgb-pulser.rs

@@ -1,38 +0,0 @@
-use rog_aura::{GX502Layout, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-    let layout = GX502Layout::default();
-
-    dbus.proxies().led().init_effect()?;
-    let rows = layout.get_rows();
-
-    let mut fade = 50;
-    let mut flip = false;
-    loop {
-        for row in rows {
-            for (k, key) in row.iter().enumerate() {
-                if let Some(c) = key_colours.key(*key) {
-                    *c.0 = 255 / fade / (k + 1) as u8;
-                };
-            }
-        }
-
-        dbus.proxies().led().set_per_key(&key_colours)?;
-
-        if flip {
-            if fade > 1 {
-                fade -= 1;
-            } else {
-                flip = !flip;
-            }
-        } else if fade < 17 {
-            fade += 1;
-        } else {
-            flip = !flip;
-        }
-    }
-}

asusctl/examples/aura-zoned-breathe.rs

@@ -0,0 +1,69 @@
+//! Using a combination of key-colour array plus a key layout to generate
+//! outputs.
+
+use rog_aura::effects::{AdvancedEffects, Effect};
+use rog_aura::keyboard::{KeyLayout, LedCode};
+use rog_aura::Colour;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let layout = KeyLayout::default_layout();
+
+    let conn = Connection::system().unwrap();
+    let proxy = AuraProxyBlocking::new(&conn).unwrap();
+
+    let mut seq = AdvancedEffects::new(true);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::Single,
+    //     Colour(166, 127, 166),
+    //     Colour(127, 155, 20),
+    //     rog_aura::Speed::High,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::DoomLightFlash(rog_aura::effects::DoomLightFlash::new(
+    //     RgbAddress::Single,
+    //     Colour(200, 0, 0),
+    //     80,
+    //     10,
+    // ));
+    // seq.push(zone);
+
+    let zone = Effect::DoomFlicker(rog_aura::effects::DoomFlicker::new(
+        LedCode::SingleZone,
+        Colour {
+            r: 200,
+            g: 110,
+            b: 0,
+        },
+        100,
+        10,
+    ));
+    seq.push(zone);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::KeyboardCenterLeft,
+    //     Colour(16, 127, 255),
+    //     Colour(127, 15, 20),
+    //     rog_aura::Speed::Low,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::LightbarRightCorner,
+    //     Colour(0, 255, 255),
+    //     Colour(255, 0, 255),
+    //     rog_aura::Speed::Med,
+    // ));
+    // seq.push(zone);
+
+    loop {
+        seq.next_state(&layout);
+        let packets = seq.create_packets();
+
+        proxy.direct_addressing_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(33));
+    }
+}

asusctl/src/anime_cli.rs

@@ -1,76 +1,88 @@
 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
-    }
-}
+use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
+use rog_anime::AnimeType;
 
 #[derive(Options)]
 pub struct AnimeCommand {
     #[options(help = "print help message")]
     pub help: bool,
+    #[options(meta = "", help = "override the display type")]
+    pub override_type: Option<AnimeType>,
+    #[options(meta = "", help = "enable/disable the display")]
+    pub enable_display: Option<bool>,
+    #[options(meta = "", help = "enable/disable the builtin run/powersave animation")]
+    pub enable_powersave_anim: Option<bool>,
     #[options(
         meta = "",
-        help = "turn on/off the panel (accept/reject write requests)"
+        help = "set global base brightness value <Off, Low, Med, High>"
     )]
-    pub turn: Option<AnimeStatusValue>,
-    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
-    pub boot: Option<AnimeStatusValue>,
+    pub brightness: Option<Brightness>,
+    #[options(help = "clear the display")]
+    pub clear: bool,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when external power is unplugged"
+    )]
+    pub off_when_unplugged: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the laptop suspends"
+    )]
+    pub off_when_suspended: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the lid is closed"
+    )]
+    pub off_when_lid_closed: Option<bool>,
+    #[options(no_short, meta = "", help = "Off with his head!!!")]
+    pub off_with_his_head: Option<bool>,
     #[options(command)]
     pub command: Option<AnimeActions>,
 }
 
 #[derive(Options)]
 pub enum AnimeActions {
-    #[options(help = "change all leds brightness")]
-    Leds(AnimeLeds),
-    #[options(help = "display an image 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),
+    #[options(help = "change which builtin animations are shown")]
+    SetBuiltins(Builtins),
+}
+
+#[derive(Options)]
+pub struct Builtins {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchConstruction, StaticEmergence>"
+    )]
+    pub boot: AnimBooting,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BinaryBannerScroll, RogLogoGlitch>"
+    )]
+    pub awake: AnimAwake,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BannerSwipe, Starfield>"
+    )]
+    pub sleep: AnimSleeping,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchOut, SeeYa>"
+    )]
+    pub shutdown: AnimShutdown,
+    #[options(meta = "", help = "set/apply the animations <true/false>")]
+    pub set: Option<bool>,
 }
 
 #[derive(Options)]
@@ -90,3 +102,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

@@ -1,17 +1,74 @@
-use gumdrop::Options;
-use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 use std::str::FromStr;
 
+use gumdrop::Options;
+use rog_aura::error::Error;
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
+
+#[derive(Options, Debug)]
+pub struct LedPowerCommand1 {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")]
+    pub awake: Option<bool>,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub keyboard: bool,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub lightbar: bool,
+    #[options(meta = "", help = "Control boot animations <true/false>")]
+    pub boot: Option<bool>,
+    #[options(meta = "", help = "Control suspend animations <true/false>")]
+    pub sleep: Option<bool>,
+}
+
+#[derive(Options, Debug)]
+pub struct LedPowerCommand2 {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(command)]
+    pub command: Option<SetAuraZoneEnabled>,
+}
+
+#[derive(Options, Debug)]
+pub enum SetAuraZoneEnabled {
+    /// Applies to both old and new models
+    #[options(help = "")]
+    Keyboard(AuraPowerStates),
+    #[options(help = "")]
+    Logo(AuraPowerStates),
+    #[options(help = "")]
+    Lightbar(AuraPowerStates),
+    #[options(help = "")]
+    Lid(AuraPowerStates),
+    #[options(help = "")]
+    RearGlow(AuraPowerStates),
+    #[options(help = "")]
+    Ally(AuraPowerStates),
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct AuraPowerStates {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub boot: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub awake: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub sleep: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub shutdown: bool,
+}
+
 #[derive(Options)]
 pub struct LedBrightness {
-    level: Option<u32>,
+    level: Option<u8>,
 }
 impl LedBrightness {
-    pub fn new(level: Option<u32>) -> Self {
+    pub fn new(level: Option<u8>) -> Self {
         LedBrightness { level }
     }
 
-    pub fn level(&self) -> Option<u32> {
+    pub fn level(&self) -> Option<u8> {
         self.level
     }
 }
@@ -32,6 +89,7 @@ impl FromStr for LedBrightness {
         }
     }
 }
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for LedBrightness {
     fn to_string(&self) -> String {
         let s = match self.level {
@@ -40,7 +98,7 @@ impl ToString for LedBrightness {
             Some(0x02) => "high",
             _ => "unknown",
         };
-        s.to_string()
+        s.to_owned()
     }
 }
 
@@ -50,7 +108,14 @@ pub struct SingleSpeed {
     help: bool,
     #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
+
 #[derive(Debug, Clone, Options, Default)]
 pub struct SingleSpeedDirection {
     #[options(help = "print help message")]
@@ -59,6 +124,12 @@ pub struct SingleSpeedDirection {
     pub direction: Direction,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
@@ -67,6 +138,12 @@ pub struct SingleColour {
     help: bool,
     #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour: Colour,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
@@ -77,6 +154,12 @@ pub struct SingleColourSpeed {
     pub colour: Colour,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Options, Default)]
@@ -89,10 +172,17 @@ pub struct TwoColourSpeed {
     pub colour2: Colour,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
-pub struct MultiColour {
+#[allow(dead_code)]
+pub struct MultiZone {
     #[options(help = "print help message")]
     help: bool,
     #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
@@ -106,6 +196,7 @@ pub struct MultiColour {
 }
 
 #[derive(Debug, Clone, Default, Options)]
+#[allow(dead_code)]
 pub struct MultiColourSpeed {
     #[options(help = "print help message")]
     help: bool,
@@ -124,38 +215,33 @@ 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")]
-    Static(SingleColour),
+    Static(SingleColour), // 0
     #[options(help = "pulse between one or two colours")]
-    Breathe(TwoColourSpeed),
+    Breathe(TwoColourSpeed), // 1
     #[options(help = "strobe through all colours")]
-    Strobe(SingleSpeed),
+    RainbowCycle(SingleSpeed), // 2
     #[options(help = "rainbow cycling in one of four directions")]
-    Rainbow(SingleSpeedDirection),
+    RainbowWave(SingleSpeedDirection), // 3
     #[options(help = "rain pattern mimicking raindrops")]
-    Stars(TwoColourSpeed),
+    Stars(TwoColourSpeed), // 4
     #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed),
+    Rain(SingleSpeed), // 5
     #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed),
+    Highlight(SingleColourSpeed), // 6
     #[options(help = "pressed keys generate horizontal laser")]
-    Laser(SingleColourSpeed),
+    Laser(SingleColourSpeed), // 7
     #[options(help = "pressed keys ripple outwards like a splash")]
-    Ripple(SingleColourSpeed),
+    Ripple(SingleColourSpeed), // 8
     #[options(help = "set a rapid pulse")]
-    Pulse(SingleColour),
+    Pulse(SingleColour), // 10
     #[options(help = "set a vertical line zooming from left")]
-    Comet(SingleColour),
+    Comet(SingleColour), // 11
     #[options(help = "set a wide vertical line zooming from left")]
-    Flash(SingleColour),
-    #[options(help = "4-zone multi-colour")]
-    MultiStatic(MultiColour),
-    #[options(help = "4-zone multi-colour breathing")]
-    MultiBreathe(MultiColourSpeed),
+    Flash(SingleColour), // 12
 }
 
 impl Default for SetAuraBuiltin {
@@ -168,6 +254,7 @@ impl From<&SingleColour> for AuraEffect {
     fn from(aura: &SingleColour) -> Self {
         Self {
             colour1: aura.colour,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -177,6 +264,7 @@ impl From<&SingleSpeed> for AuraEffect {
     fn from(aura: &SingleSpeed) -> Self {
         Self {
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -187,6 +275,7 @@ impl From<&SingleColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -197,6 +286,7 @@ impl From<&TwoColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             colour2: aura.colour2,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -207,6 +297,7 @@ impl From<&SingleSpeedDirection> for AuraEffect {
         Self {
             speed: aura.speed,
             direction: aura.direction,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -225,14 +316,14 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Breathe;
                 data
             }
-            SetAuraBuiltin::Strobe(x) => {
+            SetAuraBuiltin::RainbowCycle(x) => {
                 let mut data: AuraEffect = x.into();
-                data.mode = AuraModeNum::Strobe;
+                data.mode = AuraModeNum::RainbowCycle;
                 data
             }
-            SetAuraBuiltin::Rainbow(x) => {
+            SetAuraBuiltin::RainbowWave(x) => {
                 let mut data: AuraEffect = x.into();
-                data.mode = AuraModeNum::Rainbow;
+                data.mode = AuraModeNum::RainbowWave;
                 data
             }
             SetAuraBuiltin::Stars(x) => {
@@ -275,55 +366,6 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Flash;
                 data
             }
-            _ => AuraEffect::default(),
         }
     }
 }
-
-impl From<&SetAuraBuiltin> for Vec<AuraEffect> {
-    fn from(aura: &SetAuraBuiltin) -> Vec<AuraEffect> {
-        let mut zones = vec![AuraEffect::default(); 4];
-        match aura {
-            SetAuraBuiltin::MultiStatic(data) => {
-                zones[0].mode = AuraModeNum::Static;
-                zones[0].zone = AuraZone::One;
-                zones[0].colour1 = data.colour1;
-
-                zones[1].mode = AuraModeNum::Static;
-                zones[1].zone = AuraZone::Two;
-                zones[1].colour1 = data.colour2;
-
-                zones[2].mode = AuraModeNum::Static;
-                zones[2].zone = AuraZone::Three;
-                zones[2].colour1 = data.colour3;
-
-                zones[3].mode = AuraModeNum::Static;
-                zones[3].zone = AuraZone::Four;
-                zones[3].colour1 = data.colour4;
-            }
-            SetAuraBuiltin::MultiBreathe(data) => {
-                zones[0].mode = AuraModeNum::Breathe;
-                zones[0].zone = AuraZone::One;
-                zones[0].colour1 = data.colour1;
-                zones[0].speed = data.speed;
-
-                zones[1].mode = AuraModeNum::Breathe;
-                zones[1].zone = AuraZone::Two;
-                zones[1].colour1 = data.colour2;
-                zones[1].speed = data.speed;
-
-                zones[2].mode = AuraModeNum::Breathe;
-                zones[2].zone = AuraZone::Three;
-                zones[2].colour1 = data.colour3;
-                zones[2].speed = data.speed;
-
-                zones[3].mode = AuraModeNum::Breathe;
-                zones[3].zone = AuraZone::Four;
-                zones[3].colour1 = data.colour4;
-                zones[3].speed = data.speed;
-            }
-            _ => {}
-        }
-        zones
-    }
-}

asusctl/src/cli_opts.rs

@@ -1,9 +1,11 @@
-use crate::{
-    anime_cli::AnimeCommand,
-    aura_cli::{LedBrightness, SetAuraBuiltin},
-    profiles_cli::{FanCurveCommand, ProfileCommand},
-};
 use gumdrop::Options;
+use rog_platform::platform::PlatformProfile;
+
+use crate::anime_cli::AnimeCommand;
+use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
+use crate::fan_curve_cli::FanCurveCommand;
+use crate::scsi_cli::ScsiCommand;
+use crate::slash_cli::SlashCommand;
 
 #[derive(Default, Options)]
 pub struct CliStart {
@@ -21,6 +23,8 @@ pub struct CliStart {
     pub prev_kbd_bright: bool,
     #[options(meta = "", help = "Set your battery charge limit <20-100>")]
     pub chg_limit: Option<u8>,
+    #[options(help = "Toggle one-shot battery charge to 100%")]
+    pub one_shot_chg: bool,
     #[options(command)]
     pub command: Option<CliCommand>,
 }
@@ -28,7 +32,11 @@ pub struct CliStart {
 #[derive(Options)]
 pub enum CliCommand {
     #[options(help = "Set the keyboard lighting from built-in modes")]
-    LedMode(LedModeCommand),
+    Aura(LedModeCommand),
+    #[options(help = "Set the LED power states")]
+    AuraPowerOld(LedPowerCommand1),
+    #[options(help = "Set the LED power states")]
+    AuraPower(LedPowerCommand2),
     #[options(help = "Set or select platform_profile")]
     Profile(ProfileCommand),
     #[options(help = "Set, select, or modify fan curves if supported")]
@@ -37,8 +45,45 @@ pub enum CliCommand {
     Graphics(GraphicsCommand),
     #[options(name = "anime", help = "Manage AniMe Matrix")]
     Anime(AnimeCommand),
-    #[options(help = "Change bios settings")]
-    Bios(BiosCommand),
+    #[options(name = "slash", help = "Manage Slash Ledbar")]
+    Slash(SlashCommand),
+    #[options(name = "scsi", help = "Manage SCSI external drive")]
+    Scsi(ScsiCommand),
+    #[options(
+        help = "Change platform settings. This is a new interface exposed by the asus-armoury \
+                driver, some of the settings will be the same as the older platform interface"
+    )]
+    Armoury(ArmouryCommand),
+    #[options(name = "backlight", help = "Set screen backlight levels")]
+    Backlight(BacklightCommand),
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct ProfileCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "toggle to next profile in list")]
+    pub next: bool,
+
+    #[options(help = "list available profiles")]
+    pub list: bool,
+
+    #[options(help = "get profile")]
+    pub profile_get: bool,
+
+    #[options(meta = "", help = "set the active profile")]
+    pub profile_set: Option<PlatformProfile>,
+
+    #[options(short = "a", meta = "", help = "set the profile to use on AC power")]
+    pub profile_set_ac: Option<PlatformProfile>,
+
+    #[options(
+        short = "b",
+        meta = "",
+        help = "set the profile to use on battery power"
+    )]
+    pub profile_set_bat: Option<PlatformProfile>,
 }
 
 #[derive(Options)]
@@ -49,16 +94,6 @@ pub struct LedModeCommand {
     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 awake_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(command)]
     pub command: Option<SetAuraBuiltin>,
 }
@@ -70,23 +105,30 @@ pub struct GraphicsCommand {
 }
 
 #[derive(Options, Debug)]
-pub struct BiosCommand {
+pub struct ArmouryCommand {
     #[options(help = "print help message")]
     pub help: bool,
     #[options(
-        meta = "",
-        no_long,
-        help = "set bios POST sound: asusctl -p <true/false>"
+        free,
+        help = "append each value name followed by the value to set. `-1` sets to default"
     )]
-    pub post_sound_set: Option<bool>,
-    #[options(no_long, help = "read bios POST sound")]
-    pub post_sound_get: bool,
+    pub free: Vec<String>,
+}
+
+#[derive(Options)]
+pub struct BacklightCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "Set screen brightness <0-100>")]
+    pub screenpad_brightness: Option<i32>,
     #[options(
         meta = "",
-        no_long,
-        help = "activate dGPU dedicated/G-Sync: asusctl -d <true/false>, reboot required"
+        help = "Set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
     )]
-    pub dedicated_gfx_set: Option<bool>,
-    #[options(no_long, help = "get GPU mode")]
-    pub dedicated_gfx_get: bool,
+    pub screenpad_gamma: Option<f32>,
+    #[options(
+        meta = "",
+        help = "Set screenpad brightness to sync with primary display"
+    )]
+    pub sync_screenpad_brightness: Option<bool>,
 }

asusctl/src/fan_curve_cli.rs

@@ -0,0 +1,49 @@
+use gumdrop::Options;
+use rog_platform::platform::PlatformProfile;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::FanCurvePU;
+
+#[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 = "profile to modify fan-curve for. Shows data if no options provided"
+    )]
+    pub mod_profile: Option<PlatformProfile>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> fan all curves for a profile. `--mod_profile` \
+                required"
+    )]
+    pub enable_fan_curves: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> a single fan curve for a profile. `--mod_profile` \
+                and `--fan` required"
+    )]
+    pub enable_fan_curve: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "select fan <cpu/gpu/mid> to modify. `--mod_profile` required"
+    )]
+    pub fan: Option<FanCurvePU>,
+
+    #[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>,
+}

asusctl/src/profiles_cli.rs

@@ -1,51 +0,0 @@
-use gumdrop::Options;
-use rog_profiles::{fan_curve_set::CurveData, FanCurvePU, Profile};
-
-#[derive(Debug, Clone, Options)]
-pub struct ProfileCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(help = "toggle to next profile in list")]
-    pub next: bool,
-    #[options(help = "list available profiles")]
-    pub list: bool,
-
-    #[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 = "profile to modify fan-curve for. Shows data if no options provided"
-    )]
-    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>,
-
-    #[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>,
-}

asusctl/src/scsi_cli.rs

@@ -0,0 +1,35 @@
+use gumdrop::Options;
+use rog_scsi::{AuraMode, Colour, Direction, Speed};
+
+#[derive(Options)]
+pub struct ScsiCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "Enable the SCSI drive LEDs")]
+    pub enable: Option<bool>,
+
+    #[options(meta = "", help = "Set LED mode (so 'list' for all options)")]
+    pub mode: Option<AuraMode>,
+
+    #[options(
+        meta = "",
+        help = "Set LED mode speed <slowest, slow, med, fast, fastest> (does not apply to all)"
+    )]
+    pub speed: Option<Speed>,
+
+    #[options(
+        meta = "",
+        help = "Set LED mode direction <forward, reverse> (does not apply to all)"
+    )]
+    pub direction: Option<Direction>,
+
+    #[options(
+        meta = "",
+        help = "Set LED colours <hex>, specify up to 4 with repeated arg"
+    )]
+    pub colours: Vec<Colour>,
+
+    #[options(help = "list available animations")]
+    pub list: bool,
+}

asusctl/src/slash_cli.rs

@@ -0,0 +1,37 @@
+use gumdrop::Options;
+use rog_slash::SlashMode;
+
+#[derive(Options)]
+pub struct SlashCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "Enable the Slash Ledbar")]
+    pub enable: bool,
+    #[options(help = "Disable the Slash Ledbar")]
+    pub disable: bool,
+    #[options(short = "l", meta = "", help = "Set brightness value <0-255>")]
+    pub brightness: Option<u8>,
+    #[options(meta = "", help = "Set interval value <0-5>")]
+    pub interval: Option<u8>,
+    #[options(meta = "", help = "Set SlashMode (so 'list' for all options)")]
+    pub mode: Option<SlashMode>,
+    #[options(help = "list available animations")]
+    pub list: bool,
+
+    #[options(short = "B", meta = "", help = "Show the animation on boot")]
+    pub show_on_boot: Option<bool>,
+    #[options(short = "S", meta = "", help = "Show the animation on shutdown")]
+    pub show_on_shutdown: Option<bool>,
+    #[options(short = "s", meta = "", help = "Show the animation on sleep")]
+    pub show_on_sleep: Option<bool>,
+    #[options(short = "b", meta = "", help = "Show the animation on battery")]
+    pub show_on_battery: Option<bool>,
+    // #[options(short = "L", meta = "", help = "Show the animation on lid closed")]
+    // pub show_on_lid_closed: Option<bool>,
+    #[options(
+        short = "w",
+        meta = "",
+        help = "Show the low-battery warning animation"
+    )]
+    pub show_battery_warning: Option<bool>,
+}

asusd-user/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "asusd-user"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "asusd-user"
+path = "src/daemon.rs"
+
+[features]
+default = []
+local_data = []
+
+[dependencies]
+dirs.workspace = true
+smol.workspace = true
+
+# serialisation
+serde.workspace = true
+ron.workspace = true
+
+rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
+rog_dbus = { path = "../rog-dbus" }
+rog_platform = { path = "../rog-platform" }
+config-traits = { path = "../config-traits" }
+
+zbus.workspace = true
+env_logger.workspace = true
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+An user utility for Linux to control fancy things on various ASUS laptops
+like keyboard effects or anime matrix animation cycles."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusd-user", "usr/bin/", "755"],
+  ["../asusd_user-fakeinstall/usr/lib/systemd/user/*", "usr/lib/systemd/user/", "644"],
+]

asusd-user/src/config.rs

@@ -0,0 +1,232 @@
+use std::path::PathBuf;
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences as AnimeSequences, Vec2};
+use rog_aura::effects::{AdvancedEffects as AuraSequences, Breathe, DoomFlicker, Effect, Static};
+use rog_aura::keyboard::LedCode;
+use rog_aura::{Colour, Speed};
+use serde::{Deserialize, Serialize};
+
+use crate::error::Error;
+
+const ROOT_CONF_DIR: &str = "rog";
+
+fn root_conf_dir() -> PathBuf {
+    let mut dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+    dir.push(ROOT_CONF_DIR);
+    dir
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAnime {
+    pub name: String,
+    pub anime: Vec<ActionLoader>,
+}
+
+impl ConfigAnime {
+    pub fn create(&self, anime_type: AnimeType) -> Result<AnimeSequences, Error> {
+        let mut seq = AnimeSequences::new(anime_type);
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAnime {
+    fn default() -> Self {
+        Self {
+            name: "anime-default".to_owned(),
+            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,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(6),
+                        None,
+                        Duration::from_secs(3),
+                    )),
+                },
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::Image {
+                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
+                    scale: 1.0,
+                    angle: 0.0,
+                    translation: Vec2::default(),
+                    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)),
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                    scale: 0.9,
+                    angle: 0.0,
+                    translation: Vec2::new(3.0, 2.0),
+                    brightness: 0.5,
+                    time: AnimTime::Count(2),
+                },
+            ],
+        }
+    }
+}
+
+impl StdConfig for ConfigAnime {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAnime {}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAura {
+    pub name: String,
+    pub aura: AuraSequences,
+}
+
+impl ConfigAura {
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAura {
+    fn default() -> Self {
+        let mut seq = AuraSequences::new(false);
+        let mut key = Effect::Breathe(Breathe::new(
+            LedCode::W,
+            Colour {
+                r: 255,
+                g: 0,
+                b: 20,
+            },
+            Colour {
+                r: 20,
+                g: 255,
+                b: 0,
+            },
+            Speed::Low,
+        ));
+
+        seq.push(key.clone());
+        key.set_led(LedCode::A);
+        seq.push(key.clone());
+        key.set_led(LedCode::S);
+        seq.push(key.clone());
+        key.set_led(LedCode::D);
+        seq.push(key);
+
+        let key = Effect::Breathe(Breathe::new(
+            LedCode::F,
+            Colour { r: 255, g: 0, b: 0 },
+            Colour { r: 255, g: 0, b: 0 },
+            Speed::High,
+        ));
+        seq.push(key);
+
+        let mut key = Effect::Static(Static::new(LedCode::RCtrl, Colour { r: 0, g: 0, b: 255 }));
+        seq.push(key.clone());
+        key.set_led(LedCode::LCtrl);
+        seq.push(key.clone());
+        key.set_led(LedCode::Esc);
+        seq.push(key);
+
+        let key = Effect::DoomFlicker(DoomFlicker::new(
+            LedCode::N9,
+            Colour { r: 0, g: 0, b: 255 },
+            80,
+            40,
+        ));
+        seq.push(key);
+
+        Self {
+            name: "aura-default".to_owned(),
+            aura: seq,
+        }
+    }
+}
+
+impl StdConfig for ConfigAura {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAura {}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ConfigBase {
+    /// Name of active anime config file in the user config directory
+    pub active_anime: Option<String>,
+    /// Name of active aura config file in the user config directory
+    pub active_aura: Option<String>,
+}
+
+impl StdConfig for ConfigBase {
+    fn new() -> Self {
+        Self {
+            active_anime: Some("anime-default".to_owned()),
+            active_aura: Some("aura-default".to_owned()),
+        }
+    }
+
+    fn file_name(&self) -> String {
+        "rog-user.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigBase {}

asusd-user/src/ctrl_anime.rs

@@ -1,44 +1,40 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use config_traits::StdConfig;
 use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
-use rog_dbus::RogDbusClient;
-use serde_derive::{Deserialize, Serialize};
-use std::time::Duration;
-use std::{
-    path::Path,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Mutex,
-    },
-};
-use std::{sync::Arc, thread::sleep, time::Instant};
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-use zvariant_derive::Type;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use ron::ser::PrettyConfig;
+use serde::{Deserialize, Serialize};
+use zbus::interface;
+use zbus::zvariant::{ObjectPath, Type};
 
-use crate::{error::Error, user_config::UserAnimeConfig};
+use crate::config::ConfigAnime;
+use crate::error::Error;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
 pub struct Timer {
     type_of: TimeType,
-    /// If time type is Timer then this is milliseonds, otherwise it is animation loop count
+    /// If time type is Timer then this is milliseonds, otherwise it is
+    /// animation loop count
     count: u64,
     /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
-    fade_in: Option<u64>,
+    fade_in: u64,
     /// Used only for `TimeType::Timer`, milliseonds to fade the image out for
-    fade_out: Option<u64>,
+    fade_out: u64,
 }
 
 impl From<Timer> for AnimTime {
     fn from(time: Timer) -> Self {
         match time.type_of {
             TimeType::Timer => {
-                if time.fade_in.is_some() || time.fade_out.is_some() {
-                    let fade_in = time
-                        .fade_in
-                        .map_or(Duration::from_secs(0), Duration::from_millis);
-                    let fade_out = time
-                        .fade_out
-                        .map_or(Duration::from_secs(0), Duration::from_millis);
+                if time.fade_in != 0 && time.fade_out != 0 {
+                    let fade_in = Duration::from_millis(time.fade_in);
+                    let fade_out = Duration::from_millis(time.fade_out);
                     let show_for = if time.count != 0 {
                         Some(Duration::from_millis(time.count))
                     } else {
@@ -62,18 +58,18 @@ pub enum TimeType {
     Infinite,
 }
 
-/// The inner object exists to allow the zbus proxy to share it with a runner thread
-/// and a zbus server behind `Arc<Mutex<T>>`
+/// The inner object exists to allow the zbus proxy to share it with a runner
+/// thread and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: RogDbusClient<'a>,
+    client: AnimeProxyBlocking<'a>,
     do_early_return: Arc<AtomicBool>,
 }
 
-impl<'a> CtrlAnimeInner<'static> {
+impl CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: RogDbusClient<'static>,
+        client: AnimeProxyBlocking<'static>,
         do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
@@ -82,8 +78,10 @@ impl<'a> CtrlAnimeInner<'static> {
             do_early_return,
         })
     }
-    /// To be called on each main loop iteration to pump out commands to the anime
-    pub fn run(&'a self) -> Result<(), Error> {
+
+    /// To be called on each main loop iteration to pump out commands to the
+    /// anime
+    pub fn run(&self) -> Result<(), Error> {
         if self.do_early_return.load(Ordering::SeqCst) {
             return Ok(());
         }
@@ -91,20 +89,18 @@ 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| {
+                    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())
-                        .ok();
+                    self.client.write(image.as_ref().clone()).ok();
                 }
                 ActionData::Pause(duration) => {
                     let start = Instant::now();
@@ -118,10 +114,10 @@ impl<'a> CtrlAnimeInner<'static> {
                         sleep(Duration::from_millis(1));
                     }
                 }
-                ActionData::AudioEq => {}
-                ActionData::SystemInfo => {}
-                ActionData::TimeDate => {}
-                ActionData::Matrix => {}
+                ActionData::AudioEq
+                | ActionData::SystemInfo
+                | ActionData::TimeDate
+                | ActionData::Matrix => {}
             }
         }
 
@@ -130,18 +126,18 @@ impl<'a> CtrlAnimeInner<'static> {
 }
 
 pub struct CtrlAnime<'a> {
-    config: Arc<Mutex<UserAnimeConfig>>,
-    client: RogDbusClient<'a>,
+    config: Arc<Mutex<ConfigAnime>>,
+    client: AnimeProxyBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
 }
 
-impl<'a> CtrlAnime<'static> {
+impl CtrlAnime<'static> {
     pub fn new(
-        config: Arc<Mutex<UserAnimeConfig>>,
+        config: Arc<Mutex<ConfigAnime>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: RogDbusClient<'static>,
+        client: AnimeProxyBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
@@ -152,12 +148,11 @@ 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
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
+            .object_server()
+            .at(&ObjectPath::from_str_unchecked("/xyz/ljones/Anime"), self)
+            .await
             .map_err(|err| {
                 println!("CtrlAnime: add_to_server {}", err);
                 err
@@ -172,12 +167,12 @@ impl<'a> CtrlAnime<'static> {
 // - Do actions
 // - Write config if required
 // - Unset inner_early_return
-#[dbus_interface(name = "org.asuslinux.Daemon")]
+#[interface(name = "xyz.ljones.Asusd")]
 impl CtrlAnime<'static> {
     pub fn insert_asus_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         time: Timer,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
@@ -200,13 +195,14 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
-            let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
 
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -215,7 +211,7 @@ impl CtrlAnime<'static> {
     pub fn insert_image_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
@@ -245,14 +241,13 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
-
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+            config.write();
 
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -261,7 +256,7 @@ impl CtrlAnime<'static> {
     pub fn insert_image(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
@@ -290,14 +285,13 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
-
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+            config.write();
 
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -315,14 +309,13 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
-
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+            config.write();
 
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -338,14 +331,13 @@ impl CtrlAnime<'static> {
             if (index as usize) < config.anime.len() {
                 config.anime.remove(index as usize);
             }
-            config.write()?;
-
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+            config.write();
 
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -353,13 +345,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.set_enable_display(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.set_enable_display(on).ok();
         }
         Ok(())
     }

asusd-user/src/daemon.rs

@@ -0,0 +1,118 @@
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use asusd_user::config::*;
+use asusd_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::usb::get_anime_type;
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::KeyLayout;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use rog_dbus::{list_iface_blocking, DBUS_NAME};
+use smol::Executor;
+use zbus::Connection;
+
+#[cfg(not(feature = "local_data"))]
+const DATA_DIR: &str = "/usr/share/rog-gui/";
+#[cfg(feature = "local_data")]
+const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .init();
+
+    println!("  user daemon v{}", asusd_user::VERSION);
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
+
+    let conn = zbus::blocking::Connection::system().unwrap();
+
+    let supported = list_iface_blocking()?;
+    let config = ConfigBase::new().load();
+    let executor = Executor::new();
+
+    let early_return = Arc::new(AtomicBool::new(false));
+    // Set up the anime data and run loop/thread
+    if supported.contains(&"xyz.ljones.Anime".to_string()) {
+        if let Some(cfg) = config.active_anime {
+            let anime_type = get_anime_type();
+            let anime_config = ConfigAnime::new().set_name(cfg).load();
+            let anime = anime_config.create(anime_type)?;
+            let anime_config = Arc::new(Mutex::new(anime_config));
+
+            let anime_proxy_blocking = AnimeProxyBlocking::new(&conn).unwrap();
+            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,
+                            anime_proxy_blocking.clone(),
+                            early_return.clone(),
+                        )
+                        .unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let anime_control = CtrlAnime::new(
+                        anime_config,
+                        inner.clone(),
+                        anime_proxy_blocking,
+                        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 let Some(cfg) = config.active_aura {
+        let mut aura_config = ConfigAura::new().set_name(cfg).load();
+        // let baord_name = std::fs::read_to_string(BOARD_NAME)?;
+
+        let led_support = LedSupportData::get_data("");
+
+        let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
+            .map_err(|e| {
+                println!("{BOARD_NAME}, {e}");
+            })
+            .unwrap_or_else(|_| KeyLayout::default_layout());
+
+        let aura_proxy_blocking = AuraProxyBlocking::new(&conn).unwrap();
+        executor
+            .spawn(async move {
+                loop {
+                    aura_config.aura.next_state(&layout);
+                    let packets = aura_config.aura.create_packets();
+
+                    aura_proxy_blocking.direct_addressing_raw(packets).unwrap();
+                    std::thread::sleep(std::time::Duration::from_millis(33));
+                }
+            })
+            .detach();
+    }
+    // }
+
+    loop {
+        smol::block_on(executor.tick());
+    }
+}

asusd-user/src/error.rs

@@ -13,7 +13,7 @@ pub enum Error {
 
 impl fmt::Display for Error {
     // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::Io(err) => write!(f, "Failed to open: {}", err),
             Error::ConfigLoadFail => write!(f, "Failed to load user config"),

asusd-user/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod user_config;
+pub mod config;
 
 pub mod error;
 
@@ -6,6 +6,4 @@ pub mod ctrl_anime;
 
 pub mod zbus_anime;
 
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");

asusd-user/src/zbus_anime.rs

@@ -1,7 +1,8 @@
-//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//! # `DBus` interface proxy for: `xyz.ljones.Asusd`
 //!
-//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
-//! Source: `Interface '/org/asuslinux/Anime' from service 'org.asuslinux.Daemon' on session bus`.
+//! This code was generated by `zbus-xmlgen` `1.0.0` from `DBus` introspection
+//! data. Source: `Interface '/xyz/ljones/Anime' from service
+//! 'xyz.ljones.Asusd' on session bus`.
 //!
 //! You may prefer to adapt it, instead of using it verbatim.
 //!
@@ -9,8 +10,8 @@
 //! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
 //! section of the zbus documentation.
 //!
-//! This DBus object implements
-//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! This `DBus` object implements
+//! [standard `DBus` interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
 //! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
 //!
 //! * [`zbus::fdo::PeerProxy`]
@@ -20,9 +21,9 @@
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 #![allow(clippy::too_many_arguments)]
 
-use zbus::dbus_proxy;
+use zbus::proxy;
 
-#[dbus_proxy(interface = "org.asuslinux.Daemon")]
+#[proxy(interface = "xyz.ljones.Asusd", default_path = "/xyz/ljones/Anime")]
 trait Daemon {
     /// InsertAsusGif method
     fn insert_asus_gif(

asusd/Cargo.toml

@@ -0,0 +1,62 @@
+[package]
+name = "asusd"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "asusd"
+path = "src/daemon.rs"
+
+[dependencies]
+config-traits = { path = "../config-traits" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
+rog_slash = { path = "../rog-slash", features = ["dbus"] }
+rog_aura = { path = "../rog-aura", features = ["dbus"] }
+rog_scsi = { path = "../rog-scsi", features = ["dbus"] }
+rog_platform = { path = "../rog-platform" }
+rog_profiles = { path = "../rog-profiles" }
+dmi_id = { path = "../dmi-id" }
+futures-lite = "*"
+udev.workspace = true
+inotify.workspace = true
+
+mio.workspace = true
+tokio.workspace = true
+# console-subscriber = "0.2.0"
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+futures-util.workspace = true
+zbus.workspace = true
+logind-zbus.workspace = true
+
+# serialisation
+serde.workspace = true
+
+concat-idents.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+The dbus server for asusctl and rog-control-center applications."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusd", "usr/bin/", "755"],
+  ["../asusd-fakeinstall/usr/lib/systemd/system/*", "usr/lib/systemd/system/", "644"],
+  ["../asusd-fakeinstall/usr/lib/udev/rules.d/*", "usr/lib/udev/rules.d/", "644"],
+  ["../asusd-fakeinstall/usr/share/asusd/*", "usr/share/share/asusd/", "644"],
+  ["../asusd-fakeinstall/usr/share/dbus-1/system.d/*", "usr/share/dbus-1/system.d/", "644"],
+]

asusd/src/asus_armoury.rs

@@ -0,0 +1,564 @@
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_platform::asus_armoury::{AttrValue, Attribute, FirmwareAttribute, FirmwareAttributes};
+use rog_platform::platform::{PlatformProfile, RogPlatform};
+use rog_platform::power::AsusPower;
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use zbus::object_server::SignalEmitter;
+use zbus::zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Type, Value};
+use zbus::{fdo, interface, Connection};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{Reloadable, ASUS_ZBUS_PATH};
+
+const MOD_NAME: &str = "asus_armoury";
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize, Type, Value, OwnedValue)]
+pub struct PossibleValues {
+    strings: Vec<String>,
+    nums: Vec<i32>,
+}
+
+fn dbus_path_for_attr(attr_name: &str) -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{attr_name}")).into()
+}
+
+#[derive(Clone)]
+pub struct AsusArmouryAttribute {
+    attr: Attribute,
+    config: Arc<Mutex<Config>>,
+    /// platform control required here for access to PPD or Throttle profile
+    platform: RogPlatform,
+    power: AsusPower,
+}
+
+impl AsusArmouryAttribute {
+    pub fn new(
+        attr: Attribute,
+        platform: RogPlatform,
+        power: AsusPower,
+        config: Arc<Mutex<Config>>,
+    ) -> Self {
+        Self {
+            attr,
+            config,
+            platform,
+            power,
+        }
+    }
+
+    pub fn attribute_name(&self) -> String {
+        String::from(self.attr.name())
+    }
+
+    fn resolve_i32_value(refreshed: Option<i32>, cached: &AttrValue) -> i32 {
+        refreshed
+            .or(match cached {
+                AttrValue::Integer(i) => Some(*i),
+                _ => None,
+            })
+            .unwrap_or(-1)
+    }
+
+    pub async fn emit_limits(&self, connection: &Connection) -> Result<(), RogError> {
+        let path = dbus_path_for_attr(self.attr.name());
+        let signal = SignalEmitter::new(connection, path)?;
+        self.min_value_changed(&signal).await?;
+        self.max_value_changed(&signal).await?;
+        self.scalar_increment_changed(&signal).await?;
+        self.current_value_changed(&signal).await?;
+        Ok(())
+    }
+
+    pub async fn move_to_zbus(self, connection: &Connection) -> Result<(), RogError> {
+        let path = dbus_path_for_attr(self.attr.name());
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+
+    async fn watch_and_notify(
+        &mut self,
+        signal_ctxt: SignalEmitter<'static>,
+    ) -> Result<(), RogError> {
+        use futures_util::StreamExt;
+
+        let name = self.name();
+        macro_rules! watch_value_notify {
+            ($attr_str:expr, $fn_prop_changed:ident) => {
+                match self.attr.get_watcher($attr_str) {
+                    Ok(watch) => {
+                        let name = <&str>::from(name);
+                        let ctrl = self.clone();
+                        let sig = signal_ctxt.clone();
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
+                                stream
+                                    .for_each(|_| async {
+                                        debug!("{} changed", name);
+                                        ctrl.$fn_prop_changed(&sig).await.ok();
+                                    })
+                                    .await;
+                            } else {
+                                info!(
+                                    "inotify event stream failed for {} ({}). You can ignore this \
+                                     if unsupported",
+                                    name, $attr_str
+                                );
+                            }
+                        });
+                    }
+                    Err(e) => info!(
+                        "inotify watch failed: {}. You can ignore this if your device does not \
+                         support the feature",
+                        e
+                    ),
+                }
+            };
+        }
+
+        // "current_value", "default_value", "min_value", "max_value"
+        watch_value_notify!("current_value", current_value_changed);
+        watch_value_notify!("default_value", default_value_changed);
+        watch_value_notify!("min_value", min_value_changed);
+        watch_value_notify!("max_value", max_value_changed);
+
+        Ok(())
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct ArmouryAttributeRegistry {
+    attrs: Vec<AsusArmouryAttribute>,
+}
+
+impl ArmouryAttributeRegistry {
+    pub fn push(&mut self, attr: AsusArmouryAttribute) {
+        self.attrs.push(attr);
+    }
+
+    pub async fn emit_limits(&self, connection: &Connection) -> Result<(), RogError> {
+        let mut last_err: Option<RogError> = None;
+        for attr in &self.attrs {
+            if let Err(e) = attr.emit_limits(connection).await {
+                error!(
+                    "Failed to emit updated limits for attribute '{}': {e:?}",
+                    attr.attribute_name()
+                );
+                last_err = Some(e);
+            }
+        }
+        if let Some(err) = last_err {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl crate::Reloadable for AsusArmouryAttribute {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        info!("Reloading {}", self.attr.name());
+        let name: FirmwareAttribute = self.attr.name().into();
+
+        // Treat dGPU attributes the same as PPT attributes for power-profile
+        // behaviour so they follow AC/DC tuning groups.
+        if name.is_ppt() || name.is_dgpu() {
+            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+            let power_plugged = self
+                .power
+                .get_online()
+                .map_err(|e| {
+                    error!("Could not get power status: {e:?}");
+                    e
+                })
+                .unwrap_or_default()
+                == 1;
+
+            let apply_value = {
+                let config = self.config.lock().await;
+                config
+                    .select_tunings_ref(power_plugged, profile)
+                    .and_then(|tuning| {
+                        if tuning.enabled {
+                            tuning.group.get(&self.name()).copied()
+                        } else {
+                            None
+                        }
+                    })
+            };
+
+            if let Some(tune) = apply_value {
+                self.attr
+                    .set_current_value(&AttrValue::Integer(tune))
+                    .map_err(|e| {
+                        error!("Could not set {} value: {e:?}", self.attr.name());
+                        self.attr.base_path_exists();
+                        e
+                    })?;
+                info!(
+                    "Restored PPT armoury setting {} to {:?}",
+                    self.attr.name(),
+                    tune
+                );
+            } else {
+                info!("Ignored restoring PPT armoury setting {} as tuning group is disabled or no saved value", self.attr.name());
+            }
+        } else {
+            // Handle non-PPT attributes (boolean and other settings)
+            if let Some(saved_value) = self.config.lock().await.armoury_settings.get(&name) {
+                self.attr
+                    .set_current_value(&AttrValue::Integer(*saved_value))
+                    .map_err(|e| {
+                        error!(
+                            "Error restoring armoury setting {}: {e:?}",
+                            self.attr.name()
+                        );
+                        self.attr.base_path_exists();
+                        e
+                    })?;
+                info!(
+                    "Restored armoury setting {} to {:?}",
+                    self.attr.name(),
+                    saved_value
+                );
+            } else {
+                info!(
+                    "No saved armoury setting for {}: skipping restore",
+                    self.attr.name()
+                );
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// If return is `-1` on a property then there is avilable value for that
+/// property
+#[interface(name = "xyz.ljones.AsusArmoury")]
+impl AsusArmouryAttribute {
+    #[zbus(property)]
+    fn name(&self) -> FirmwareAttribute {
+        self.attr.name().into()
+    }
+
+    #[zbus(property)]
+    async fn available_attrs(&self) -> Vec<String> {
+        let mut attrs = Vec::new();
+        if !matches!(self.attr.default_value(), AttrValue::None) {
+            attrs.push("default_value".to_string());
+        }
+        if !matches!(self.attr.min_value(), AttrValue::None) {
+            attrs.push("min_value".to_string());
+        }
+        if !matches!(self.attr.max_value(), AttrValue::None) {
+            attrs.push("max_value".to_string());
+        }
+        if !matches!(self.attr.scalar_increment(), AttrValue::None) {
+            attrs.push("scalar_increment".to_string());
+        }
+        if !matches!(self.attr.possible_values(), AttrValue::None) {
+            attrs.push("possible_values".to_string());
+        }
+        // TODO: Don't unwrap, use error
+        if let Ok(value) = self.attr.current_value().map_err(|e| {
+            error!("Failed to read: {e:?}");
+            e
+        }) {
+            if !matches!(value, AttrValue::None) {
+                attrs.push("current_value".to_string());
+            }
+        }
+        attrs
+    }
+
+    /// If return is `-1` then there is no default value
+    #[zbus(property)]
+    async fn default_value(&self) -> i32 {
+        match self.attr.default_value() {
+            AttrValue::Integer(i) => *i,
+            _ => -1,
+        }
+    }
+
+    async fn restore_default(&self) -> fdo::Result<()> {
+        self.attr.restore_default()?;
+        if self.name().is_ppt() || self.name().is_dgpu() {
+            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+            let power_plugged = self
+                .power
+                .get_online()
+                .map_err(|e| {
+                    error!("Could not get power status: {e:?}");
+                    e
+                })
+                .unwrap_or_default();
+
+            let mut config = self.config.lock().await;
+            let tuning = config.select_tunings(power_plugged == 1, profile);
+            if let Some(tune) = tuning.group.get_mut(&self.name()) {
+                if let AttrValue::Integer(i) = self.attr.default_value() {
+                    *tune = *i;
+                }
+            }
+            if tuning.enabled {
+                self.attr
+                    .set_current_value(self.attr.default_value())
+                    .map_err(|e| {
+                        error!("Could not set value: {e:?}");
+                        e
+                    })?;
+            }
+            config.write();
+        }
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn min_value(&self) -> i32 {
+        Self::resolve_i32_value(self.attr.refresh_min_value(), self.attr.min_value())
+    }
+
+    #[zbus(property)]
+    async fn max_value(&self) -> i32 {
+        Self::resolve_i32_value(self.attr.refresh_max_value(), self.attr.max_value())
+    }
+
+    #[zbus(property)]
+    async fn scalar_increment(&self) -> i32 {
+        Self::resolve_i32_value(
+            self.attr.refresh_scalar_increment(),
+            self.attr.scalar_increment(),
+        )
+    }
+
+    #[zbus(property)]
+    async fn possible_values(&self) -> Vec<i32> {
+        match self.attr.possible_values() {
+            AttrValue::EnumInt(i) => i.clone(),
+            _ => Vec::default(),
+        }
+    }
+
+    #[zbus(property)]
+    async fn current_value(&self) -> fdo::Result<i32> {
+        if self.name().is_ppt() || self.name().is_dgpu() {
+            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+            let power_plugged = self
+                .power
+                .get_online()
+                .map_err(|e| {
+                    error!("Could not get power status: {e:?}");
+                    e
+                })
+                .unwrap_or_default()
+                == 1;
+            let config = self.config.lock().await;
+            if let Some(tuning) = config.select_tunings_ref(power_plugged, profile) {
+                if let Some(tune) = tuning.group.get(&self.name()) {
+                    return Ok(*tune);
+                }
+            }
+            if let AttrValue::Integer(i) = self.attr.default_value() {
+                return Ok(*i);
+            }
+            return Err(fdo::Error::Failed(
+                "Could not read current value".to_string(),
+            ));
+        }
+
+        if let Ok(AttrValue::Integer(i)) = self.attr.current_value() {
+            return Ok(i);
+        }
+        Err(fdo::Error::Failed(
+            "Could not read current value".to_string(),
+        ))
+    }
+
+    #[zbus(property)]
+    async fn set_current_value(&mut self, value: i32) -> fdo::Result<()> {
+        if self.name().is_ppt() || self.name().is_dgpu() {
+            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+            let power_plugged = self
+                .power
+                .get_online()
+                .map_err(|e| {
+                    error!("Could not get power status: {e:?}");
+                    e
+                })
+                .unwrap_or_default();
+
+            let mut config = self.config.lock().await;
+            let tuning = config.select_tunings(power_plugged == 1, profile);
+
+            if let Some(tune) = tuning.group.get_mut(&self.name()) {
+                *tune = value;
+            } else {
+                tuning.group.insert(self.name(), value);
+                debug!("Store tuning config for {} = {:?}", self.attr.name(), value);
+            }
+            if tuning.enabled {
+                self.attr
+                    .set_current_value(&AttrValue::Integer(value))
+                    .map_err(|e| {
+                        error!(
+                            "Could not set value to PPT property {}: {e:?}",
+                            self.attr.name()
+                        );
+                        e
+                    })?;
+            } else {
+                warn!(
+                    "Tuning group is disabled: skipping setting value to PPT property {}",
+                    self.attr.name()
+                );
+            }
+        } else {
+            self.attr
+                .set_current_value(&AttrValue::Integer(value))
+                .map_err(|e| {
+                    error!(
+                        "Could not set value {value} to attribute {}: {e:?}",
+                        self.attr.name()
+                    );
+                    e
+                })?;
+
+            let mut settings = self.config.lock().await;
+            settings
+                .armoury_settings
+                .entry(self.name())
+                .and_modify(|setting| {
+                    debug!("Set config for {} = {value}", self.attr.name());
+                    *setting = value;
+                })
+                .or_insert_with(|| {
+                    debug!("Adding config for {} = {value}", self.attr.name());
+                    value
+                });
+        }
+
+        // write config after setting value
+        self.config.lock().await.write();
+        Ok(())
+    }
+}
+
+pub async fn start_attributes_zbus(
+    conn: &Connection,
+    platform: RogPlatform,
+    power: AsusPower,
+    attributes: FirmwareAttributes,
+    config: Arc<Mutex<Config>>,
+) -> Result<ArmouryAttributeRegistry, RogError> {
+    let mut registry = ArmouryAttributeRegistry::default();
+    for attr in attributes.attributes() {
+        let mut attr = AsusArmouryAttribute::new(
+            attr.clone(),
+            platform.clone(),
+            power.clone(),
+            config.clone(),
+        );
+
+        let registry_attr = attr.clone();
+
+        if let Err(e) = attr.reload().await {
+            error!(
+                "Skipping attribute '{}' due to reload error: {e:?}",
+                attr.attr.name()
+            );
+            break;
+        }
+
+        let attr_name = attr.attribute_name();
+
+        let path = dbus_path_for_attr(attr_name.as_str());
+        match zbus::object_server::SignalEmitter::new(conn, path) {
+            Ok(sig) => {
+                if let Err(e) = attr.watch_and_notify(sig).await {
+                    error!("Failed to start watcher for '{}': {e:?}", attr.attr.name());
+                }
+            }
+            Err(e) => {
+                error!(
+                    "Failed to create SignalEmitter for '{}': {e:?}",
+                    attr.attr.name()
+                );
+            }
+        }
+
+        if let Err(e) = attr.move_to_zbus(conn).await {
+            error!("Failed to register attribute '{attr_name}' on zbus: {e:?}");
+            continue;
+        }
+
+        registry.push(registry_attr);
+    }
+    Ok(registry)
+}
+
+pub async fn set_config_or_default(
+    attrs: &FirmwareAttributes,
+    config: &mut Config,
+    power_plugged: bool,
+    profile: PlatformProfile,
+) {
+    for attr in attrs.attributes().iter() {
+        let name: FirmwareAttribute = attr.name().into();
+        if name.is_ppt() || name.is_dgpu() {
+            let tuning = config.select_tunings(power_plugged, profile);
+            if !tuning.enabled {
+                debug!("Tuning group is not enabled, skipping");
+                return;
+            }
+
+            if let Some(tune) = tuning.group.get(&name) {
+                attr.set_current_value(&AttrValue::Integer(*tune))
+                    .map_err(|e| {
+                        error!("Failed to set {}: {e}", <&str>::from(name));
+                    })
+                    .ok();
+            } else {
+                let default = attr.default_value();
+                attr.set_current_value(default)
+                    .map_err(|e| {
+                        error!("Failed to set {}: {e}", <&str>::from(name));
+                    })
+                    .ok();
+                if let AttrValue::Integer(i) = default {
+                    tuning.group.insert(name, *i);
+                    info!(
+                        "Set default tuning config for {} = {:?}",
+                        <&str>::from(name),
+                        i
+                    );
+                    // config.write();
+                }
+            }
+        } else {
+            // Handle non-PPT attributes (boolean and other settings)
+            if let Some(saved_value) = config.armoury_settings.get(&name) {
+                attr.set_current_value(&AttrValue::Integer(*saved_value))
+                    .map_err(|e| {
+                        error!("Failed to set {}: {e}", <&str>::from(name));
+                    })
+                    .ok();
+                info!(
+                    "Restored armoury setting for {} = {:?}",
+                    <&str>::from(name),
+                    saved_value
+                );
+            }
+        }
+    }
+}

asusd/src/aura_anime/config.rs

@@ -0,0 +1,182 @@
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::Brightness;
+use rog_anime::{
+    ActionData, ActionLoader, AnimTime, Animations, AnimeType, DeviceState, Fade, Vec2,
+};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "anime.ron";
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct AniMeConfigCached {
+    pub system: Vec<ActionData>,
+    pub boot: Vec<ActionData>,
+    pub wake: Vec<ActionData>,
+    pub shutdown: Vec<ActionData>,
+}
+
+impl AniMeConfigCached {
+    pub fn init_from_config(
+        &mut self,
+        config: &AniMeConfig,
+        anime_type: AnimeType,
+    ) -> Result<(), AnimeError> {
+        let mut sys = Vec::with_capacity(config.system.len());
+        for ani in &config.system {
+            sys.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.system = sys;
+
+        let mut boot = Vec::with_capacity(config.boot.len());
+        for ani in &config.boot {
+            boot.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.boot = boot;
+
+        let mut wake = Vec::with_capacity(config.wake.len());
+        for ani in &config.wake {
+            wake.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.wake = wake;
+
+        let mut shutdown = Vec::with_capacity(config.shutdown.len());
+        for ani in &config.shutdown {
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.shutdown = shutdown;
+        Ok(())
+    }
+}
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct AniMeConfig {
+    #[serde(skip)]
+    pub anime_type: AnimeType,
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    // pub brightness: f32,
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub off_when_unplugged: bool,
+    pub off_when_suspended: bool,
+    pub off_when_lid_closed: bool,
+    pub brightness_on_battery: Brightness,
+    pub builtin_anims: Animations,
+}
+
+impl Default for AniMeConfig {
+    fn default() -> Self {
+        AniMeConfig {
+            anime_type: AnimeType::GA402,
+            system: Vec::new(),
+            boot: Vec::new(),
+            wake: Vec::new(),
+            shutdown: Vec::new(),
+            // brightness: 1.0,
+            display_enabled: true,
+            display_brightness: Brightness::Med,
+            builtin_anims_enabled: true,
+            off_when_unplugged: true,
+            off_when_suspended: true,
+            off_when_lid_closed: true,
+            brightness_on_battery: Brightness::Low,
+            builtin_anims: Animations::default(),
+        }
+    }
+}
+
+impl StdConfig for AniMeConfig {
+    fn new() -> Self {
+        Self::create_default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for AniMeConfig {}
+
+impl From<&AniMeConfig> for DeviceState {
+    fn from(config: &AniMeConfig) -> Self {
+        DeviceState {
+            display_enabled: config.display_enabled,
+            display_brightness: config.display_brightness,
+            builtin_anims_enabled: config.builtin_anims_enabled,
+            builtin_anims: config.builtin_anims,
+            off_when_unplugged: config.off_when_unplugged,
+            off_when_suspended: config.off_when_suspended,
+            off_when_lid_closed: config.off_when_lid_closed,
+            brightness_on_battery: config.brightness_on_battery,
+        }
+    }
+}
+
+impl AniMeConfig {
+    // fn clamp_config_brightness(mut config: &mut AnimeConfig) {
+    //     if config.brightness < 0.0 || config.brightness > 1.0 {
+    //         warn!(
+    //             "Clamped brightness to [0.0 ; 1.0], was {}",
+    //             config.brightness
+    //         );
+    //         config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
+    //     }
+    // }
+
+    fn create_default() -> Self {
+        // create a default config here
+        AniMeConfig {
+            system: vec![],
+            boot: vec![
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+            ],
+            wake: vec![
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+            ],
+            shutdown: vec![
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                    scale: 0.9,
+                    angle: 0.0,
+                    translation: Vec2::new(3.0, 2.0),
+                    brightness: 1.0,
+                    time: AnimTime::Infinite,
+                },
+            ],
+            ..Default::default()
+        }
+    }
+}

asusd/src/aura_anime/mod.rs

@@ -0,0 +1,248 @@
+pub mod config;
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
+pub mod trait_impls;
+
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread::sleep;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_anime::usb::{
+    pkt_flush, pkt_set_brightness, pkt_set_enable_display, pkt_set_enable_powersave_anim,
+    pkts_for_init, Brightness,
+};
+use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use tokio::sync::Mutex;
+
+use self::config::{AniMeConfig, AniMeConfigCached};
+use crate::error::RogError;
+
+#[derive(Debug, Clone)]
+pub struct AniMe {
+    hid: Option<Arc<Mutex<HidRaw>>>,
+    usb: Option<Arc<Mutex<USBRaw>>>,
+    config: Arc<Mutex<AniMeConfig>>,
+    cache: AniMeConfigCached,
+    // set to force thread to exit
+    thread_exit: Arc<AtomicBool>,
+    // Set to false when the thread exits
+    thread_running: Arc<AtomicBool>,
+}
+
+impl AniMe {
+    pub fn new(
+        hid: Option<Arc<Mutex<HidRaw>>>,
+        usb: Option<Arc<Mutex<USBRaw>>>,
+        config: Arc<Mutex<AniMeConfig>>,
+    ) -> Self {
+        Self {
+            hid,
+            usb,
+            config,
+            cache: AniMeConfigCached::default(),
+            thread_exit: Arc::new(AtomicBool::new(false)),
+            thread_running: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    /// Will fail if something is already holding the config lock
+    async fn do_init_cache(&mut self) {
+        if let Ok(mut config) = self.config.try_lock() {
+            if let Err(e) = self.cache.init_from_config(&config, config.anime_type) {
+                error!(
+                    "Trying to cache the Anime Config failed, will reset to default config: {e:?}"
+                );
+                config.rename_file_old();
+                *config = AniMeConfig::new();
+                config.write();
+            } else {
+                debug!("Initialised AniMe cache");
+            }
+        } else {
+            error!("AniMe Matrix could not init cache")
+        }
+    }
+
+    /// Initialise the device if required.
+    pub async fn do_initialization(&mut self) -> Result<(), RogError> {
+        self.do_init_cache().await;
+        let pkts = pkts_for_init();
+        self.write_bytes(&pkts[0]).await?;
+        self.write_bytes(&pkts[1]).await?;
+        debug!("Succesfully initialised AniMe matrix display");
+        Ok(())
+    }
+
+    pub async fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        if let Some(hid) = &self.hid {
+            hid.lock().await.write_bytes(message)?;
+        } else if let Some(usb) = &self.usb {
+            usb.lock().await.write_bytes(message)?;
+        }
+        Ok(())
+    }
+
+    /// Write only a data packet. This will modify the leds brightness using the
+    /// global brightness set in config.
+    async fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> {
+        for led in buffer.data_mut().iter_mut() {
+            let mut bright = *led as f32;
+            if bright > 254.0 {
+                bright = 254.0;
+            }
+            *led = bright as u8;
+        }
+        let data = AnimePacketType::try_from(buffer)?;
+        for row in &data {
+            self.write_bytes(row).await?;
+        }
+        self.write_bytes(&pkt_flush()).await
+    }
+
+    pub async fn set_builtins_enabled(
+        &self,
+        enabled: bool,
+        bright: Brightness,
+    ) -> Result<(), RogError> {
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))
+            .await?;
+        self.write_bytes(&pkt_set_enable_display(enabled)).await?;
+        self.write_bytes(&pkt_set_brightness(bright)).await?;
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))
+            .await
+    }
+
+    /// 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.
+    async fn run_thread(&self, actions: Vec<ActionData>, mut once: bool) {
+        if actions.is_empty() {
+            warn!("AniMe system actions was empty");
+            return;
+        }
+
+        self.write_bytes(&pkt_set_enable_powersave_anim(false))
+            .await
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+
+        let thread_exit = self.thread_exit.clone();
+        let thread_running = self.thread_running.clone();
+        let anime_type = self.config.lock().await.anime_type;
+        let inner = self.clone();
+
+        // 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
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main
+        // thread)
+        tokio::spawn(async move {
+            info!("AniMe new system thread started");
+            // 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);
+            }
+
+            info!("AniMe no previous system thread running (now)");
+            thread_exit.store(false, Ordering::SeqCst);
+            thread_running.store(true, Ordering::SeqCst);
+            'main: loop {
+                for action in &actions {
+                    if thread_exit.load(Ordering::SeqCst) {
+                        break 'main;
+                    }
+                    match action {
+                        ActionData::Animation(frames) => {
+                            // TODO: sort all this out
+                            rog_anime::run_animation(frames, &|frame| {
+                                if thread_exit.load(Ordering::Acquire) {
+                                    info!("rog-anime: animation sub-loop was asked to exit");
+                                    return Ok(true); // Do safe exit
+                                }
+                                let inner = inner.clone();
+                                tokio::task::spawn(async move {
+                                    inner
+                                        .write_data_buffer(frame)
+                                        .await
+                                        .map_err(|err| {
+                                            warn!("rog_anime::run_animation:callback {}", err);
+                                        })
+                                        .ok();
+                                });
+                                Ok(false) // Don't exit yet
+                            });
+                            if thread_exit.load(Ordering::Acquire) {
+                                info!("rog-anime: sub-loop exited and main loop exiting now");
+                                break 'main;
+                            }
+                        }
+                        ActionData::Image(image) => {
+                            once = false;
+                            inner
+                                .write_data_buffer(image.as_ref().clone())
+                                .await
+                                .map_err(|e| error!("{}", e))
+                                .ok();
+                        }
+                        ActionData::Pause(duration) => sleep(*duration),
+                        ActionData::AudioEq
+                        | ActionData::SystemInfo
+                        | ActionData::TimeDate
+                        | ActionData::Matrix => {}
+                    }
+                }
+                if thread_exit.load(Ordering::SeqCst) {
+                    break 'main;
+                }
+                if once || actions.is_empty() {
+                    break 'main;
+                }
+            }
+            // Clear the display on exit
+            if let Ok(data) =
+                AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()])
+                    .map_err(|e| error!("{}", e))
+            {
+                inner
+                    .write_data_buffer(data)
+                    .await
+                    .map_err(|err| {
+                        warn!("rog_anime::run_animation:callback {}", err);
+                    })
+                    .ok();
+            }
+            // A write can block for many milliseconds so lets not hold the config lock for
+            // the same period
+            let enabled = inner.config.lock().await.builtin_anims_enabled;
+            inner
+                .write_bytes(&pkt_set_enable_powersave_anim(enabled))
+                .await
+                .map_err(|err| {
+                    warn!("rog_anime::run_animation:callback {}", err);
+                })
+                .ok();
+            // Loop ended, set the atmonics
+            thread_running.store(false, Ordering::SeqCst);
+            info!("AniMe system thread exited");
+        })
+        .await
+        .map(|err| info!("AniMe system thread: {:?}", err))
+        .ok();
+    }
+}

asusd/src/aura_anime/trait_impls.rs

@@ -0,0 +1,507 @@
+use std::sync::atomic::Ordering;
+
+use config_traits::StdConfig;
+use log::{debug, error, warn};
+use logind_zbus::manager::ManagerProxy;
+use rog_anime::usb::{
+    pkt_set_brightness, pkt_set_builtin_animations, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, Brightness,
+};
+use rog_anime::{Animations, AnimeDataBuffer, DeviceState};
+use zbus::object_server::SignalEmitter;
+use zbus::proxy::CacheProperties;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::config::AniMeConfig;
+use super::AniMe;
+use crate::error::RogError;
+use crate::Reloadable;
+
+async fn get_logind_manager<'a>() -> ManagerProxy<'a> {
+    let connection = Connection::system()
+        .await
+        .expect("Controller could not create dbus connection");
+
+    ManagerProxy::builder(&connection)
+        .cache_properties(CacheProperties::No)
+        .build()
+        .await
+        .expect("Controller could not create ManagerProxy")
+}
+
+#[derive(Clone)]
+pub struct AniMeZbus(AniMe);
+
+impl AniMeZbus {
+    pub fn new(anime: AniMe) -> Self {
+        Self(anime)
+    }
+
+    pub async fn start_tasks(
+        mut self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        // let task = zbus.clone();
+        self.reload()
+            .await
+            .unwrap_or_else(|err| warn!("Controller error: {}", err));
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| {
+                error!("Couldn't add server at path: {path}, {e:?}");
+                e
+            })?;
+        debug!("start_tasks was successful");
+        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.
+#[interface(name = "xyz.ljones.Anime")]
+impl AniMeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until
+    /// it is restarted
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        let bright = self.0.config.lock().await.display_brightness;
+        if self.0.config.lock().await.builtin_anims_enabled {
+            // This clears the display, causing flickers if done indiscriminately on every
+            // write. Therefore, we guard it behind a config check.
+            self.0.set_builtins_enabled(false, bright).await?;
+        }
+        self.0.thread_exit.store(true, Ordering::SeqCst);
+        self.0.write_data_buffer(input).await.map_err(|err| {
+            warn!("ctrl_anime::run_animation:callback {}", err);
+            err
+        })?;
+        Ok(())
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> Brightness {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.display_brightness;
+        }
+        Brightness::Off
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: Brightness) {
+        self.0
+            .write_bytes(&pkt_set_brightness(brightness))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+        self.0
+            .write_bytes(&pkt_set_enable_display(brightness != Brightness::Off))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+
+        let mut config = self.0.config.lock().await;
+        config.display_enabled = brightness != Brightness::Off;
+        config.display_brightness = brightness;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn builtins_enabled(&self) -> bool {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.builtin_anims_enabled;
+        }
+        false
+    }
+
+    /// Enable the builtin animations or not. This is quivalent to "Powersave
+    /// animations" in Armory crate
+    #[zbus(property)]
+    async fn set_builtins_enabled(&self, enabled: bool) {
+        let mut config = self.0.config.lock().await;
+        let brightness = config.display_brightness;
+        self.0
+            .set_builtins_enabled(enabled, brightness)
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            })
+            .ok();
+
+        if !enabled {
+            let anime_type = config.anime_type;
+            let data = vec![255u8; anime_type.data_length()];
+            if let Ok(tmp) = AnimeDataBuffer::from_vec(anime_type, data).map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            }) {
+                self.0
+                    .write_bytes(tmp.data())
+                    .await
+                    .map_err(|err| {
+                        warn!("ctrl_anime::set_builtins_enabled {}", err);
+                    })
+                    .ok();
+            }
+        }
+
+        config.builtin_anims_enabled = enabled;
+        config.write();
+        if enabled {
+            self.0.thread_exit.store(true, Ordering::Release);
+        }
+    }
+
+    #[zbus(property)]
+    async fn builtin_animations(&self) -> Animations {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.builtin_anims;
+        }
+        Animations::default()
+    }
+
+    /// Set which builtin animation is used for each stage
+    #[zbus(property)]
+    async fn set_builtin_animations(&self, settings: Animations) {
+        self.0
+            .write_bytes(&pkt_set_builtin_animations(
+                settings.boot, settings.awake, settings.sleep, settings.shutdown,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0
+            .write_bytes(&pkt_set_enable_powersave_anim(true))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        let mut config = self.0.config.lock().await;
+        config.display_enabled = true;
+        config.builtin_anims = settings;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn enable_display(&self) -> bool {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.display_enabled;
+        }
+        false
+    }
+
+    /// Set whether the AniMe is enabled at all
+    #[zbus(property)]
+    async fn set_enable_display(&self, enabled: bool) {
+        self.0
+            .write_bytes(&pkt_set_enable_display(enabled))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        let mut config = self.0.config.lock().await;
+        config.display_enabled = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_unplugged(&self) -> bool {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.off_when_unplugged;
+        }
+        false
+    }
+
+    /// Set if to turn the AniMe Matrix off when external power is unplugged
+    #[zbus(property)]
+    async fn set_off_when_unplugged(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let pow = manager.on_external_power().await.unwrap_or_default();
+
+        self.0
+            .write_bytes(&pkt_set_enable_display(!pow && !enabled))
+            .await
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        let mut config = self.0.config.lock().await;
+        config.off_when_unplugged = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_suspended(&self) -> bool {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.off_when_suspended;
+        }
+        false
+    }
+
+    /// Set if to turn the AniMe Matrix off when the laptop is suspended
+    #[zbus(property)]
+    async fn set_off_when_suspended(&self, enabled: bool) {
+        let mut config = self.0.config.lock().await;
+        config.off_when_suspended = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_lid_closed(&self) -> bool {
+        if let Ok(config) = self.0.config.try_lock() {
+            return config.off_when_lid_closed;
+        }
+        false
+    }
+
+    /// Set if to turn the AniMe Matrix off when the lid is closed
+    #[zbus(property)]
+    async fn set_off_when_lid_closed(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let lid = manager.lid_closed().await.unwrap_or_default();
+
+        self.0
+            .write_bytes(&pkt_set_enable_display(lid && !enabled))
+            .await
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        let mut config = self.0.config.lock().await;
+        config.off_when_lid_closed = enabled;
+        config.write();
+    }
+
+    /// The main loop is the base system set action if the user isn't running
+    /// the user daemon
+    async fn run_main_loop(&self, start: bool) {
+        if start {
+            self.0.thread_exit.store(true, Ordering::SeqCst);
+            self.0.run_thread(self.0.cache.system.clone(), false).await;
+        }
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        DeviceState::from(&*self.0.config.lock().await)
+    }
+}
+
+impl crate::CtrlTask for AniMeZbus {
+    fn zbus_path() -> &'static str {
+        "ANIME_ZBUS_PATH"
+    }
+
+    async fn create_tasks(&self, _: SignalEmitter<'static>) -> Result<(), RogError> {
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                // on_sleep
+                let inner = inner1.clone();
+                async move {
+                    let config = inner.config.lock().await.clone();
+                    if config.display_enabled {
+                        inner.thread_exit.store(true, Ordering::Release); // ensure clean slate
+
+                        inner
+                            .write_bytes(&pkt_set_enable_display(
+                                !(sleeping && config.off_when_suspended),
+                            ))
+                            .await
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                            })
+                            .ok();
+
+                        if config.builtin_anims_enabled {
+                            inner
+                                .write_bytes(&pkt_set_enable_powersave_anim(
+                                    !(sleeping && config.off_when_suspended),
+                                ))
+                                .await
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        } else if !sleeping && !config.builtin_anims_enabled {
+                            // Run custom wake animation
+                            inner
+                                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                                .await
+                                .ok(); // ensure builtins are disabled
+
+                            inner.run_thread(inner.cache.wake.clone(), true).await;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                // on_shutdown
+                let inner = inner2.clone();
+                async move {
+                    let AniMeConfig {
+                        display_enabled,
+                        builtin_anims_enabled,
+                        ..
+                    } = *inner.config.lock().await;
+                    if display_enabled && !builtin_anims_enabled {
+                        if shutting_down {
+                            inner.run_thread(inner.cache.shutdown.clone(), true).await;
+                        } else {
+                            inner.run_thread(inner.cache.boot.clone(), true).await;
+                        }
+                    }
+                }
+            },
+            move |lid_closed| {
+                let inner = inner3.clone();
+                // on lid change
+                async move {
+                    let AniMeConfig {
+                        off_when_lid_closed,
+                        builtin_anims_enabled,
+                        ..
+                    } = *inner.config.lock().await;
+                    if off_when_lid_closed {
+                        if builtin_anims_enabled {
+                            inner
+                                .write_bytes(&pkt_set_enable_powersave_anim(!lid_closed))
+                                .await
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .write_bytes(&pkt_set_enable_display(!lid_closed))
+                            .await
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move |power_plugged| {
+                let inner = inner4.clone();
+                // on power change
+                async move {
+                    let AniMeConfig {
+                        off_when_unplugged,
+                        builtin_anims_enabled,
+                        brightness_on_battery,
+                        ..
+                    } = *inner.config.lock().await;
+                    if off_when_unplugged {
+                        if builtin_anims_enabled {
+                            inner
+                                .write_bytes(&pkt_set_enable_powersave_anim(power_plugged))
+                                .await
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .write_bytes(&pkt_set_enable_display(power_plugged))
+                            .await
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    } else {
+                        inner
+                            .write_bytes(&pkt_set_brightness(brightness_on_battery))
+                            .await
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for AniMeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let AniMeConfig {
+            builtin_anims_enabled,
+            builtin_anims,
+            display_enabled,
+            display_brightness,
+            off_when_lid_closed,
+            off_when_unplugged,
+            ..
+        } = *self.0.config.lock().await;
+
+        // Set builtins
+        if builtin_anims_enabled {
+            self.0
+                .write_bytes(&pkt_set_builtin_animations(
+                    builtin_anims.boot,
+                    builtin_anims.awake,
+                    builtin_anims.sleep,
+                    builtin_anims.shutdown,
+                ))
+                .await?;
+        }
+        // Builtins enabled or na?
+        self.0
+            .set_builtins_enabled(builtin_anims_enabled, display_brightness)
+            .await?;
+
+        let manager = get_logind_manager().await;
+        let lid_closed = manager.lid_closed().await.unwrap_or_default();
+        let power_plugged = manager.on_external_power().await.unwrap_or_default();
+
+        let turn_off =
+            (lid_closed && off_when_lid_closed) || (!power_plugged && off_when_unplugged);
+        self.0
+            .write_bytes(&pkt_set_enable_display(!turn_off))
+            .await
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::reload {}", err);
+            })
+            .ok();
+
+        if turn_off || !display_enabled {
+            self.0.write_bytes(&pkt_set_enable_display(false)).await?;
+            // early return so we don't run animation thread
+            return Ok(());
+        }
+
+        if !builtin_anims_enabled && !self.0.cache.boot.is_empty() {
+            self.0
+                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                .await
+                .ok();
+
+            let action = self.0.cache.boot.clone();
+            self.0.run_thread(action, true).await;
+        }
+        Ok(())
+    }
+}

asusd/src/aura_laptop/config.rs

@@ -0,0 +1,458 @@
+use std::collections::BTreeMap;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{debug, info, warn};
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::LaptopAuraPower;
+use rog_aura::{
+    AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::error::RogError;
+
+#[derive(Deserialize, Serialize, Default, Debug, Clone)]
+// #[serde(default)]
+pub struct AuraConfig {
+    #[serde(skip)]
+    pub led_type: AuraDeviceType,
+    #[serde(skip)]
+    pub support_data: LedSupportData,
+    pub config_name: String,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ally_fix: Option<bool>,
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
+    pub multizone_on: bool,
+    pub enabled: LaptopAuraPower,
+    #[serde(skip)]
+    pub per_key_mode_active: bool,
+}
+
+impl StdConfig for AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
+    fn new() -> Self {
+        panic!("This should not be used");
+    }
+
+    fn file_name(&self) -> String {
+        if self.config_name.is_empty() {
+            panic!("Config file name should not be empty");
+        }
+        self.config_name.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for AuraConfig {}
+
+impl AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
+    pub fn new(prod_id: &str) -> Self {
+        info!("Setting up AuraConfig for {prod_id:?}");
+        // create a default config here
+        let device_type = AuraDeviceType::from(prod_id);
+        if device_type == AuraDeviceType::Unknown {
+            warn!("idProduct:{prod_id:?} is unknown");
+        }
+        let support_data = LedSupportData::get_data(prod_id);
+        let enabled = LaptopAuraPower::new(device_type, &support_data);
+        let mut config = AuraConfig {
+            led_type: device_type,
+            support_data,
+            config_name: format!("aura_{prod_id}.ron"),
+            ally_fix: None,
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+            multizone_on: false,
+            enabled,
+            per_key_mode_active: false,
+        };
+
+        for n in &config.support_data.basic_modes {
+            debug!("creating default for {n}");
+            config
+                .builtins
+                .insert(*n, AuraEffect::default_with_mode(*n));
+        }
+        if !config.support_data.basic_zones.is_empty() {
+            for n in &config.support_data.basic_modes {
+                let mut default = vec![];
+                for (i, tmp) in config.support_data.basic_zones.iter().enumerate() {
+                    default.push(AuraEffect {
+                        mode: *n,
+                        zone: *tmp,
+                        colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                        colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                        speed: Speed::Med,
+                        direction: Direction::Left,
+                    });
+                }
+                if let Some(m) = config.multizone.as_mut() {
+                    m.insert(*n, default);
+                } else {
+                    let mut tmp = BTreeMap::new();
+                    tmp.insert(*n, default);
+                    config.multizone = Some(tmp);
+                }
+            }
+        }
+        config
+    }
+
+    /// Set the mode data, current mode, and if multizone enabled.
+    ///
+    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct
+    /// store.
+    pub fn set_builtin(&mut self, effect: AuraEffect) {
+        self.current_mode = effect.mode;
+        if effect.zone() == AuraZone::None {
+            self.builtins.insert(*effect.mode(), effect);
+            self.multizone_on = false;
+        } else {
+            if let Some(multi) = self.multizone.as_mut() {
+                if let Some(fx_vec) = multi.get_mut(effect.mode()) {
+                    for fx in fx_vec.iter_mut() {
+                        if fx.zone == effect.zone {
+                            *fx = effect;
+                            return;
+                        }
+                    }
+                    fx_vec.push(effect);
+                } else {
+                    multi.insert(*effect.mode(), vec![effect]);
+                }
+            } else {
+                let mut tmp = BTreeMap::new();
+                tmp.insert(*effect.mode(), vec![effect]);
+                self.multizone = Some(tmp);
+            }
+            self.multizone_on = true;
+        }
+    }
+
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
+        if let Some(multi) = &self.multizone {
+            return multi.get(&aura_type).map(|v| v.as_slice());
+        }
+        None
+    }
+
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
+    pub fn create_multizone_default(&mut self) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in self.support_data.basic_zones.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.current_mode,
+                zone: *tmp,
+                colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                speed: Speed::Med,
+                direction: Direction::Left,
+            });
+        }
+        if default.is_empty() {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        if let Some(multizones) = self.multizone.as_mut() {
+            multizones.insert(self.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.current_mode, default);
+            self.multizone = Some(tmp);
+        }
+        Ok(())
+    }
+
+    /// Reload the config from disk then verify and update it if required.
+    /// Always rewrites the file to disk.
+    pub fn load_and_update_config(prod_id: &str) -> AuraConfig {
+        // New loads data from the DB also
+        let mut config_init = AuraConfig::new(prod_id);
+        // config_init.set_filename(prod_id);
+        let mut config_loaded = config_init.clone().load();
+        // update the initialised data with what we loaded from disk
+        for mode_init in &mut config_init.builtins {
+            // update init values from loaded values if they exist
+            if let Some(loaded) = config_loaded.builtins.get(mode_init.0) {
+                *mode_init.1 = loaded.clone();
+            }
+        }
+        // Then replace just incase the initialised data contains new modes added
+        config_loaded.builtins = config_init.builtins;
+        config_loaded.support_data = config_init.support_data;
+        config_loaded.led_type = config_init.led_type;
+        config_loaded.ally_fix = config_init.ally_fix;
+
+        for enabled_init in &mut config_init.enabled.states {
+            for enabled in &mut config_loaded.enabled.states {
+                if enabled.zone == enabled_init.zone {
+                    *enabled_init = *enabled;
+                    break;
+                }
+            }
+        }
+        config_loaded.enabled = config_init.enabled;
+
+        if let (Some(mut multizone_init), Some(multizone_loaded)) =
+            (config_init.multizone, config_loaded.multizone.as_mut())
+        {
+            for mode in multizone_init.iter_mut() {
+                // update init values from loaded values if they exist
+                if let Some(loaded) = multizone_loaded.get(mode.0) {
+                    let mut new_set = Vec::new();
+                    let data = LedSupportData::get_data(prod_id);
+                    // only reuse a zone mode if the mode is supported
+                    for mode in loaded {
+                        if data.basic_modes.contains(&mode.mode) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
+        config_loaded.write();
+        config_loaded
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::{Mutex, MutexGuard, OnceLock};
+
+    use rog_aura::keyboard::AuraPowerState;
+    use rog_aura::{
+        AuraEffect, AuraModeNum, AuraZone, Colour, Direction, LedBrightness, PowerZones, Speed,
+    };
+
+    use super::AuraConfig;
+
+    // Global mutex to serialize tests that rely on process-wide environment
+    // variables
+    static TEST_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+
+    fn test_lock() -> MutexGuard<'static, ()> {
+        TEST_MUTEX
+            .get_or_init(|| Mutex::new(()))
+            .lock()
+            .expect("TEST_MUTEX poisoned")
+    }
+
+    #[test]
+    fn set_multizone_4key_config() {
+        let _guard = test_lock();
+        std::env::set_var("BOARD_NAME", "");
+        let mut config = AuraConfig::new("19b6");
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff,
+            },
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff,
+            },
+            zone: AuraZone::Key2,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00,
+            },
+            zone: AuraZone::Key3,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00,
+            },
+            zone: AuraZone::Key4,
+            ..Default::default()
+        };
+        let effect_clone = effect.clone();
+        config.set_builtin(effect);
+        // This should replace existing
+        config.set_builtin(effect_clone);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 4);
+        assert_eq!(
+            sta[0].colour1,
+            Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[1].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[2].colour1,
+            Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+        assert_eq!(
+            sta[3].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+    }
+
+    #[test]
+    fn set_multizone_multimode_config() {
+        let _guard = test_lock();
+        std::env::set_var("BOARD_NAME", "");
+        let mut config = AuraConfig::new("19b6");
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key2,
+            mode: AuraModeNum::Breathe,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key3,
+            mode: AuraModeNum::Comet,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key4,
+            mode: AuraModeNum::Pulse,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Breathe).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Comet).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Pulse).unwrap();
+        assert_eq!(sta.len(), 1);
+    }
+
+    #[test]
+    fn verify_0x1866_g531i() {
+        let _guard = test_lock();
+        std::env::set_var("BOARD_NAME", "G513I");
+        let mut config = AuraConfig::new("1866");
+
+        assert_eq!(config.brightness, LedBrightness::Med);
+        assert_eq!(config.builtins.len(), 5);
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
+        assert_eq!(config.enabled.states.len(), 1);
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::KeyboardAndLightbar,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
+    }
+
+    #[test]
+    fn verify_0x19b6_g634j() {
+        let _guard = test_lock();
+        std::env::set_var("BOARD_NAME", "G634J");
+        let mut config = AuraConfig::new("19b6");
+
+        assert_eq!(config.brightness, LedBrightness::Med);
+        assert_eq!(config.builtins.len(), 12);
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
+        assert_eq!(config.enabled.states.len(), 4);
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::Keyboard,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
+    }
+}

asusd/src/aura_laptop/mod.rs

@@ -0,0 +1,229 @@
+use std::sync::Arc;
+
+use config::AuraConfig;
+use config_traits::StdConfig;
+use log::info;
+use rog_aura::keyboard::{AuraLaptopUsbPackets, LedUsbPackets};
+use rog_aura::usb::{AURA_LAPTOP_LED_APPLY, AURA_LAPTOP_LED_SET};
+use rog_aura::{AuraDeviceType, AuraEffect, LedBrightness, PowerZones, AURA_LAPTOP_LED_MSG_LEN};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardBacklight;
+use tokio::sync::{Mutex, MutexGuard};
+
+use crate::error::RogError;
+
+pub mod config;
+pub mod trait_impls;
+
+#[derive(Debug, Clone)]
+pub struct Aura {
+    pub hid: Option<Arc<Mutex<HidRaw>>>,
+    pub backlight: Option<Arc<Mutex<KeyboardBacklight>>>,
+    pub config: Arc<Mutex<AuraConfig>>,
+}
+
+impl Aura {
+    /// Initialise the device if required.
+    pub async fn do_initialization(&self) -> Result<(), RogError> {
+        Ok(())
+    }
+
+    pub async fn lock_config(&self) -> MutexGuard<'_, AuraConfig> {
+        self.config.lock().await
+    }
+
+    /// Will lock the internal config and update. If anything else has locked
+    /// this in scope then a deadlock can occur.
+    pub async fn update_config(&self) -> Result<(), RogError> {
+        let mut config = self.config.lock().await;
+        let bright = if let Some(bl) = self.backlight.as_ref() {
+            bl.lock().await.get_brightness().unwrap_or_default()
+        } else {
+            config.brightness.into()
+        };
+        config.read();
+        config.brightness = bright.into();
+        config.write();
+        Ok(())
+    }
+
+    pub async fn write_current_config_mode(&self, config: &mut AuraConfig) -> Result<(), RogError> {
+        if config.multizone_on {
+            let mode = config.current_mode;
+            let mut create = false;
+            // There is no multizone config for this mode so create one here
+            // using the colours of rainbow if it exists, or first available
+            // mode, or random
+            if config.multizone.is_none() {
+                create = true;
+            } else if let Some(multizones) = config.multizone.as_ref() {
+                if !multizones.contains_key(&mode) {
+                    create = true;
+                }
+            }
+            if create {
+                info!("No user-set config for zone founding, attempting a default");
+                config.create_multizone_default()?;
+            }
+
+            if let Some(multizones) = config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_effect_and_apply(config.led_type, &mode).await?;
+                    }
+                }
+            }
+        } else {
+            let mode = config.current_mode;
+            if let Some(effect) = config.builtins.get(&mode).cloned() {
+                self.write_effect_and_apply(config.led_type, &effect)
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Write the AuraEffect to the device. Will lock `backlight` or `hid`.
+    ///
+    /// If per-key or software-mode is active it must be marked as disabled in
+    /// config.
+    pub async fn write_effect_and_apply(
+        &self,
+        dev_type: AuraDeviceType,
+        mode: &AuraEffect,
+    ) -> Result<(), RogError> {
+        if matches!(dev_type, AuraDeviceType::LaptopKeyboardTuf) {
+            if let Some(platform) = &self.backlight {
+                let buf = [
+                    1, mode.mode as u8, mode.colour1.r, mode.colour1.g, mode.colour1.b,
+                    mode.speed as u8,
+                ];
+                platform.lock().await.set_kbd_rgb_mode(&buf)?;
+            }
+        } else if let Some(hid_raw) = &self.hid {
+            let bytes: [u8; AURA_LAPTOP_LED_MSG_LEN] = mode.into();
+            let hid_raw = hid_raw.lock().await;
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&AURA_LAPTOP_LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&AURA_LAPTOP_LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
+        }
+
+        Ok(())
+    }
+
+    pub async fn set_brightness(&self, value: u8) -> Result<(), RogError> {
+        if let Some(backlight) = &self.backlight {
+            backlight.lock().await.set_brightness(value)?;
+            return Ok(());
+        }
+        Err(RogError::MissingFunction(
+            "No LED backlight control available".to_string(),
+        ))
+    }
+
+    /// Set combination state for boot animation/sleep animation/all leds/keys
+    /// leds/side leds LED active
+    pub async fn set_power_states(&self, config: &AuraConfig) -> Result<(), RogError> {
+        if matches!(config.led_type, rog_aura::AuraDeviceType::LaptopKeyboardTuf) {
+            if let Some(backlight) = &self.backlight {
+                // TODO: tuf bool array
+                let buf = config.enabled.to_bytes(config.led_type);
+                backlight.lock().await.set_kbd_rgb_state(&buf)?;
+            }
+        } else if let Some(hid_raw) = &self.hid {
+            let hid_raw = hid_raw.lock().await;
+            if let Some(p) = config.enabled.states.first() {
+                if p.zone == PowerZones::Ally {
+                    let msg = [
+                        0x5d,
+                        0xd1,
+                        0x09,
+                        0x01,
+                        p.new_to_byte() as u8,
+                        0x0,
+                        0x0,
+                    ];
+                    hid_raw.write_bytes(&msg)?;
+                    return Ok(());
+                }
+            }
+
+            let bytes = config.enabled.to_bytes(config.led_type);
+            let msg = [
+                0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3],
+            ];
+            hid_raw.write_bytes(&msg)?;
+        }
+        Ok(())
+    }
+
+    /// Write an effect block. This is for per-key, but can be repurposed to
+    /// write the raw factory mode packets - when doing this it is expected that
+    /// only the first `Vec` (`effect[0]`) is valid.
+    pub async fn write_effect_block(
+        &self,
+        config: &mut AuraConfig,
+        effect: &AuraLaptopUsbPackets,
+    ) -> Result<(), RogError> {
+        if config.brightness == LedBrightness::Off {
+            config.brightness = LedBrightness::Med;
+            config.write();
+        }
+
+        let pkt_type = effect[0][1];
+        const PER_KEY_TYPE: u8 = 0xbc;
+
+        if let Some(hid_raw) = &self.hid {
+            let hid_raw = hid_raw.lock().await;
+            if pkt_type != PER_KEY_TYPE {
+                config.per_key_mode_active = false;
+                hid_raw.write_bytes(&effect[0])?;
+                hid_raw.write_bytes(&AURA_LAPTOP_LED_SET)?;
+                // hid_raw.write_bytes(&LED_APPLY)?;
+            } else {
+                if !config.per_key_mode_active {
+                    let init = LedUsbPackets::get_init_msg();
+                    hid_raw.write_bytes(&init)?;
+                    config.per_key_mode_active = true;
+                }
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
+            }
+        } else if matches!(config.led_type, rog_aura::AuraDeviceType::LaptopKeyboardTuf) {
+            if let Some(tuf) = &self.backlight {
+                for row in effect.iter() {
+                    let r = row[9];
+                    let g = row[10];
+                    let b = row[11];
+                    tuf.lock().await.set_kbd_rgb_mode(&[
+                        0, 0, r, g, b, 0,
+                    ])?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub async fn fix_ally_power(&mut self) -> Result<(), RogError> {
+        if self.config.lock().await.led_type == AuraDeviceType::Ally {
+            if let Some(hid_raw) = &self.hid {
+                let mut config = self.config.lock().await;
+                if config.ally_fix.is_none() {
+                    let msg = [
+                        0x5d, 0xbd, 0x01, 0xff, 0xff, 0xff, 0xff,
+                    ];
+                    hid_raw.lock().await.write_bytes(&msg)?;
+                    info!("Reset Ally power settings to base");
+                    config.ally_fix = Some(true);
+                }
+                config.write();
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/aura_laptop/trait_impls.rs

@@ -0,0 +1,349 @@
+use std::collections::BTreeMap;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_aura::keyboard::{AuraLaptopUsbPackets, LaptopAuraPower};
+use rog_aura::{AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, LedBrightness, PowerZones};
+use zbus::fdo::Error as ZbErr;
+use zbus::object_server::SignalEmitter;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::Aura;
+use crate::error::RogError;
+use crate::{CtrlTask, Reloadable};
+
+pub const AURA_ZBUS_NAME: &str = "Aura";
+pub const AURA_ZBUS_PATH: &str = "/xyz/ljones";
+
+#[derive(Clone)]
+pub struct AuraZbus(Aura);
+
+impl AuraZbus {
+    pub fn new(aura: Aura) -> Self {
+        Self(aura)
+    }
+
+    pub async fn start_tasks(
+        mut self,
+        connection: &Connection,
+        // _signal_ctx: SignalEmitter<'static>,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        // let task = zbus.clone();
+        // let signal_ctx = signal_ctx.clone();
+        self.reload()
+            .await
+            .unwrap_or_else(|err| warn!("Controller error: {}", err));
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        // TODO: skip this until we keep handles to tasks so they can be killed
+        // task.create_tasks(signal_ctx).await
+        Ok(())
+    }
+}
+
+/// The main interface for changing, reading, or notfying
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[interface(name = "xyz.ljones.Aura")]
+impl AuraZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        self.0.config.lock().await.led_type
+    }
+
+    /// Return the current LED brightness
+    #[zbus(property)]
+    async fn brightness(&self) -> Result<LedBrightness, ZbErr> {
+        if let Some(bl) = self.0.backlight.as_ref() {
+            return Ok(bl.lock().await.get_brightness().map(|n| n.into())?);
+        }
+        Err(ZbErr::Failed("No sysfs brightness control".to_string()))
+    }
+
+    /// Set the keyboard brightness level (0-3)
+    #[zbus(property)]
+    async fn set_brightness(&mut self, brightness: LedBrightness) -> Result<(), ZbErr> {
+        if let Some(bl) = self.0.backlight.as_ref() {
+            let res = bl.lock().await.set_brightness(brightness.into());
+            if res.is_ok() {
+                let mut config = self.0.config.lock().await;
+                config.brightness = brightness;
+                config.write();
+            }
+            return Ok(res?);
+        }
+        Err(ZbErr::Failed("No sysfs brightness control".to_string()))
+    }
+
+    /// Total levels of brightness available
+    #[zbus(property)]
+    async fn supported_brightness(&self) -> Vec<LedBrightness> {
+        vec![
+            LedBrightness::Off,
+            LedBrightness::Low,
+            LedBrightness::Med,
+            LedBrightness::High,
+        ]
+    }
+
+    /// The total available modes
+    #[zbus(property)]
+    async fn supported_basic_modes(&self) -> Result<Vec<AuraModeNum>, ZbErr> {
+        let config = self.0.config.lock().await;
+        Ok(config.builtins.keys().cloned().collect())
+    }
+
+    #[zbus(property)]
+    async fn supported_basic_zones(&self) -> Result<Vec<AuraZone>, ZbErr> {
+        let config = self.0.config.lock().await;
+        Ok(config.support_data.basic_zones.clone())
+    }
+
+    #[zbus(property)]
+    async fn supported_power_zones(&self) -> Result<Vec<PowerZones>, ZbErr> {
+        let config = self.0.config.lock().await;
+        Ok(config.support_data.power_zones.clone())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode(&self) -> Result<AuraModeNum, ZbErr> {
+        // entirely possible to deadlock here, so use try instead of lock()
+        // let ctrl = self.0.lock().await;
+        // Ok(config.current_mode)
+        if let Ok(config) = self.0.config.try_lock() {
+            Ok(config.current_mode)
+        } else {
+            Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode(&mut self, num: AuraModeNum) -> Result<(), ZbErr> {
+        let mut config = self.0.config.lock().await;
+        config.current_mode = num;
+        self.0.write_current_config_mode(&mut config).await?;
+        if config.brightness == LedBrightness::Off {
+            config.brightness = LedBrightness::Med;
+        }
+        self.0.set_brightness(config.brightness.into()).await?;
+        config.write();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        // entirely possible to deadlock here, so use try instead of lock()
+        if let Ok(config) = self.0.config.try_lock() {
+            let mode = config.current_mode;
+            match config.builtins.get(&mode) {
+                Some(effect) => Ok(effect.clone()),
+                None => Err(ZbErr::Failed("Could not get the current effect".into())),
+            }
+        } else {
+            Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        let mut config = self.0.config.lock().await;
+        if !config.support_data.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !config.support_data.basic_zones.contains(&effect.zone)
+        {
+            return Err(ZbErr::NotSupported(format!(
+                "The Aura effect is not supported: {effect:?}"
+            )));
+        }
+
+        self.0
+            .write_effect_and_apply(config.led_type, &effect)
+            .await?;
+        if config.brightness == LedBrightness::Off {
+            config.brightness = LedBrightness::Med;
+        }
+        self.0.set_brightness(config.brightness.into()).await?;
+        config.set_builtin(effect);
+        config.write();
+
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
+        let config = self.0.config.lock().await;
+        config.builtins.clone()
+    }
+
+    // As property doesn't work for AuraPowerDev (complexity of serialization?)
+    #[zbus(property)]
+    async fn led_power(&self) -> LaptopAuraPower {
+        let config = self.0.config.lock().await;
+        config.enabled.clone()
+    }
+
+    /// Set a variety of states, input is array of enum.
+    /// `enabled` sets if the sent array should be disabled or enabled
+    ///
+    /// For Modern ROG devices the "enabled" flag is ignored.
+    #[zbus(property)]
+    async fn set_led_power(&mut self, options: LaptopAuraPower) -> Result<(), ZbErr> {
+        let mut config = self.0.config.lock().await;
+        for opt in options.states {
+            let zone = opt.zone;
+            for config in config.enabled.states.iter_mut() {
+                if config.zone == zone {
+                    *config = opt;
+                }
+            }
+        }
+        config.write();
+        Ok(self.0.set_power_states(&config).await.map_err(|e| {
+            warn!("{}", e);
+            e
+        })?)
+    }
+
+    /// On machine that have some form of either per-key keyboard or per-zone
+    /// this can be used to write custom effects over dbus. The input is a
+    /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
+    async fn direct_addressing_raw(&self, data: AuraLaptopUsbPackets) -> Result<(), ZbErr> {
+        let mut config = self.0.config.lock().await;
+        self.0.write_effect_block(&mut config, &data).await?;
+        Ok(())
+    }
+}
+
+impl CtrlTask for AuraZbus {
+    fn zbus_path() -> &'static str {
+        "/xyz/ljones"
+    }
+
+    async fn create_tasks(&self, _: SignalEmitter<'static>) -> Result<(), RogError> {
+        let inner1 = self.0.clone();
+        let inner3 = self.0.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                let inner1 = inner1.clone();
+                // unwrap as we want to bomb out of the task
+                async move {
+                    if !sleeping {
+                        info!("CtrlKbdLedTask reloading brightness and modes");
+                        if let Some(backlight) = &inner1.backlight {
+                            backlight
+                                .lock()
+                                .await
+                                .set_brightness(inner1.config.lock().await.brightness.into())
+                                .map_err(|e| {
+                                    error!("CtrlKbdLedTask: {e}");
+                                    e
+                                })
+                                .unwrap();
+                        }
+                        let mut config = inner1.config.lock().await;
+                        inner1
+                            .write_current_config_mode(&mut config)
+                            .await
+                            .map_err(|e| {
+                                error!("CtrlKbdLedTask: {e}");
+                                e
+                            })
+                            .unwrap();
+                    } else if sleeping {
+                        inner1
+                            .update_config()
+                            .await
+                            .map_err(|e| {
+                                error!("CtrlKbdLedTask: {e}");
+                                e
+                            })
+                            .unwrap();
+                    }
+                }
+            },
+            move |_shutting_down| {
+                let inner3 = inner3.clone();
+                async move {
+                    info!("CtrlKbdLedTask reloading brightness and modes");
+                    if let Some(backlight) = &inner3.backlight {
+                        // unwrap as we want to bomb out of the task
+                        backlight
+                            .lock()
+                            .await
+                            .set_brightness(inner3.config.lock().await.brightness.into())
+                            .map_err(|e| {
+                                error!("CtrlKbdLedTask: {e}");
+                                e
+                            })
+                            .unwrap();
+                    }
+                }
+            },
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |_power_plugged| {
+                // power change
+                async move {}
+            },
+        )
+        .await;
+
+        // let ctrl2 = self.0.clone();
+        // let ctrl = self.0.lock().await;
+        // if ctrl.led_node.has_brightness_control() {
+        //     let watch = ctrl.led_node.monitor_brightness()?;
+        //     tokio::spawn(async move {
+        //         let mut buffer = [0; 32];
+        //         watch
+        //             .into_event_stream(&mut buffer)
+        //             .unwrap()
+        //             .for_each(|_| async {
+        //                 if let Some(lock) = ctrl2.try_lock() {
+        //                     load_save(true, lock).unwrap(); // unwrap as we want
+        //                                                     // to
+        //                                                     // bomb out of the
+        //                                                     // task
+        //                 }
+        //             })
+        //             .await;
+        //     });
+        // }
+
+        Ok(())
+    }
+}
+
+impl Reloadable for AuraZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        self.0.fix_ally_power().await?;
+        debug!("reloading keyboard mode");
+        let mut config = self.0.lock_config().await;
+        self.0.write_current_config_mode(&mut config).await?;
+        debug!("reloading power states");
+        self.0
+            .set_power_states(&config)
+            .await
+            .map_err(|err| warn!("{err}"))
+            .ok();
+        Ok(())
+    }
+}

asusd/src/aura_manager.rs

@@ -0,0 +1,592 @@
+// Plan:
+// - Manager has udev monitor on USB looking for ROG devices
+// - If a device is found, add it to watch
+// - Add it to Zbus server
+// - If udev sees device removed then remove the zbus path
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use dmi_id::DMIID;
+use futures_lite::future::block_on;
+use log::{debug, error, info, warn};
+use mio::{Events, Interest, Poll, Token};
+use rog_platform::error::PlatformError;
+use rog_platform::hid_raw::HidRaw;
+use tokio::sync::Mutex;
+use udev::{Device, MonitorBuilder};
+use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+use zbus::Connection;
+
+use crate::aura_anime::trait_impls::AniMeZbus;
+use crate::aura_laptop::trait_impls::AuraZbus;
+use crate::aura_scsi::trait_impls::ScsiZbus;
+use crate::aura_slash::trait_impls::SlashZbus;
+use crate::aura_types::DeviceHandle;
+use crate::error::RogError;
+use crate::ASUS_ZBUS_PATH;
+
+const MOD_NAME: &str = "aura";
+
+/// Returns only the Device details concatenated in a form usable for
+/// adding/appending to a filename
+pub fn filename_partial(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(id_product) = parent.attribute_value("idProduct") {
+        let id_product = id_product.to_string_lossy();
+        let mut path = if let Some(devnum) = parent.attribute_value("devnum") {
+            let devnum = devnum.to_string_lossy();
+            if let Some(devpath) = parent.attribute_value("devpath") {
+                let devpath = devpath.to_string_lossy();
+                format!("{id_product}_{devnum}_{devpath}")
+            } else {
+                format!("{id_product}_{devnum}")
+            }
+        } else {
+            format!("{id_product}")
+        };
+        if path.contains('.') {
+            warn!("dbus path for {id_product} contains `.`, removing");
+            path.replace('.', "").clone_into(&mut path);
+        }
+        return Some(ObjectPath::from_str_unchecked(&path).into());
+    }
+    None
+}
+
+fn dbus_path_for_dev(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(filename) = filename_partial(parent) {
+        return Some(
+            ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{filename}"))
+                .into(),
+        );
+    }
+    None
+}
+
+fn dbus_path_for_tuf() -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/tuf")).into()
+}
+
+fn dbus_path_for_slash() -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/slash")).into()
+}
+
+fn dbus_path_for_anime() -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/anime")).into()
+}
+
+fn dbus_path_for_scsi(prod_id: &str) -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{ASUS_ZBUS_PATH}/{MOD_NAME}/{prod_id}_scsi")).into()
+}
+
+fn dev_prop_matches(dev: &Device, prop: &str, value: &str) -> bool {
+    if let Some(p) = dev.property_value(prop) {
+        return p == value;
+    }
+    false
+}
+
+/// A device.
+///
+/// Each controller within should track its dbus path so it can be removed if
+/// required.
+pub struct AsusDevice {
+    device: DeviceHandle,
+    dbus_path: OwnedObjectPath,
+    hid_key: Option<String>,
+}
+
+pub struct DeviceManager {
+    _dbus_connection: Connection,
+    _hid_handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+}
+
+impl DeviceManager {
+    #[allow(clippy::type_complexity)]
+    async fn get_or_create_hid_handle(
+        handles: &Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+        endpoint: &Device,
+    ) -> Result<(Arc<Mutex<HidRaw>>, String), RogError> {
+        let dev_node = endpoint
+            .devnode()
+            .ok_or_else(|| RogError::MissingFunction("hidraw devnode missing".to_string()))?;
+        let key = dev_node.to_string_lossy().to_string();
+
+        if let Some(existing) = handles.lock().await.get(&key).cloned() {
+            return Ok((existing, key));
+        }
+
+        let hidraw = HidRaw::from_device(endpoint.clone())?;
+        let handle = Arc::new(Mutex::new(hidraw));
+        handles.lock().await.insert(key.clone(), handle.clone());
+        Ok((handle, key))
+    }
+
+    async fn init_hid_devices(
+        connection: &Connection,
+        device: Device,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Result<Vec<AsusDevice>, RogError> {
+        let mut devices = Vec::new();
+        if let Some(usb_device) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
+            if let Some(usb_id) = usb_device.attribute_value("idProduct") {
+                if let Some(vendor_id) = usb_device.attribute_value("idVendor") {
+                    if vendor_id != "0b05" {
+                        debug!("Not ASUS vendor ID: {}", vendor_id.to_string_lossy());
+                        return Ok(devices);
+                    }
+                    // Almost all devices are identified by the productId.
+                    // So let's see what we have and:
+                    // 1. Generate an interface path
+                    // 2. Create the device
+                    // Use the top-level endpoint, not the parent
+                    if let Ok((dev, hid_key)) =
+                        Self::get_or_create_hid_handle(&handles, &device).await
+                    {
+                        debug!("Testing device {usb_id:?}");
+                        // SLASH DEVICE
+                        if let Ok(dev_type) = DeviceHandle::new_slash_hid(
+                            dev.clone(),
+                            usb_id.to_str().unwrap_or_default(),
+                        )
+                        .await
+                        {
+                            if let DeviceHandle::Slash(slash) = dev_type.clone() {
+                                let path =
+                                    dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_slash());
+                                let ctrl = SlashZbus::new(slash);
+                                ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                                devices.push(AsusDevice {
+                                    device: dev_type,
+                                    dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
+                                });
+                            }
+                        }
+                        // ANIME MATRIX DEVICE
+                        if let Ok(dev_type) = DeviceHandle::maybe_anime_hid(
+                            dev.clone(),
+                            usb_id.to_str().unwrap_or_default(),
+                        )
+                        .await
+                        {
+                            if let DeviceHandle::AniMe(anime) = dev_type.clone() {
+                                let path =
+                                    dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_anime());
+                                let ctrl = AniMeZbus::new(anime);
+                                ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                                devices.push(AsusDevice {
+                                    device: dev_type,
+                                    dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
+                                });
+                            }
+                        }
+                        // AURA LAPTOP DEVICE
+                        if let Ok(dev_type) = DeviceHandle::maybe_laptop_aura(
+                            Some(dev),
+                            usb_id.to_str().unwrap_or_default(),
+                        )
+                        .await
+                        {
+                            if let DeviceHandle::Aura(aura) = dev_type.clone() {
+                                let path =
+                                    dbus_path_for_dev(&usb_device).unwrap_or(dbus_path_for_tuf());
+                                let ctrl = AuraZbus::new(aura);
+                                ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                                devices.push(AsusDevice {
+                                    device: dev_type,
+                                    dbus_path: path,
+                                    hid_key: Some(hid_key),
+                                });
+                            }
+                        }
+                    } else {
+                        warn!("Failed to initialise shared hid handle for {usb_id:?}");
+                    }
+                }
+            }
+        }
+        Ok(devices)
+    }
+
+    /// To be called on daemon startup
+    async fn init_all_hid(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Result<Vec<AsusDevice>, RogError> {
+        // track and ensure we use only one hidraw per prod_id
+        // let mut interfaces = HashSet::new();
+        let mut devices: Vec<AsusDevice> = Vec::new();
+
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("enumerator failed".into(), err)
+        })?;
+
+        enumerator.match_subsystem("hidraw").map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("match_subsystem failed".into(), err)
+        })?;
+
+        for device in enumerator
+            .scan_devices()
+            .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
+        {
+            devices.append(&mut Self::init_hid_devices(connection, device, handles.clone()).await?);
+        }
+
+        Ok(devices)
+    }
+
+    async fn init_scsi(
+        connection: &Connection,
+        device: &Device,
+        path: OwnedObjectPath,
+    ) -> Option<AsusDevice> {
+        // "ID_MODEL_ID" "1932"
+        // "ID_VENDOR_ID" "0b05"
+        if dev_prop_matches(device, "ID_VENDOR_ID", "0b05") {
+            if let Some(dev_node) = device.devnode() {
+                let prod_id = device
+                    .property_value("ID_MODEL_ID")
+                    .unwrap_or_default()
+                    .to_string_lossy();
+                if let Ok(dev_type) =
+                    DeviceHandle::maybe_scsi(dev_node.as_os_str().to_str().unwrap(), &prod_id).await
+                {
+                    if let DeviceHandle::Scsi(scsi) = dev_type.clone() {
+                        let ctrl = ScsiZbus::new(scsi);
+                        ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                        return Some(AsusDevice {
+                            device: dev_type,
+                            dbus_path: path,
+                            hid_key: None,
+                        });
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    async fn init_all_scsi(connection: &Connection) -> Result<Vec<AsusDevice>, RogError> {
+        // track and ensure we use only one hidraw per prod_id
+        // let mut interfaces = HashSet::new();
+        let mut devices: Vec<AsusDevice> = Vec::new();
+
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("enumerator failed".into(), err)
+        })?;
+
+        enumerator.match_subsystem("block").map_err(|err| {
+            warn!("{}", err);
+            PlatformError::Udev("match_subsystem failed".into(), err)
+        })?;
+
+        let mut found = Vec::new();
+        for device in enumerator
+            .scan_devices()
+            .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
+        {
+            if let Some(serial) = device.property_value("ID_SERIAL_SHORT") {
+                let serial = serial.to_string_lossy().to_string();
+                let path = dbus_path_for_scsi(&serial);
+                if found.contains(&path) {
+                    continue;
+                }
+
+                if let Some(dev) = Self::init_scsi(connection, &device, path.clone()).await {
+                    devices.push(dev);
+                    found.push(path);
+                }
+            } else {
+                debug!("No serial for SCSI device: {:?}", device.devpath());
+            }
+        }
+
+        Ok(devices)
+    }
+
+    pub async fn find_all_devices(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Vec<AsusDevice> {
+        let mut devices: Vec<AsusDevice> = Vec::new();
+        // HID first, always
+        if let Ok(devs) = &mut Self::init_all_hid(connection, handles.clone()).await {
+            devices.append(devs);
+        }
+        // USB after, need to check if HID picked something up and if so, skip it
+        let mut do_anime = true;
+        let mut do_slash = true;
+        let mut do_kb_backlight = true;
+        for dev in devices.iter() {
+            if matches!(dev.device, DeviceHandle::Slash(_)) {
+                do_slash = false;
+            }
+            if matches!(dev.device, DeviceHandle::AniMe(_)) {
+                do_anime = false;
+            }
+            if matches!(dev.device, DeviceHandle::Aura(_) | DeviceHandle::OldAura(_)) {
+                do_kb_backlight = false;
+            }
+        }
+
+        if do_slash {
+            if let Ok(dev_type) = DeviceHandle::new_slash_usb().await {
+                if let DeviceHandle::Slash(slash) = dev_type.clone() {
+                    let path = dbus_path_for_slash();
+                    let ctrl = SlashZbus::new(slash);
+                    ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                    devices.push(AsusDevice {
+                        device: dev_type,
+                        dbus_path: path,
+                        hid_key: None,
+                    });
+                }
+            } else {
+                info!("Tested device was not Slash");
+            }
+        }
+
+        if do_anime {
+            if let Ok(dev_type) = DeviceHandle::maybe_anime_usb().await {
+                // TODO: this is copy/pasted
+                if let DeviceHandle::AniMe(anime) = dev_type.clone() {
+                    let path = dbus_path_for_anime();
+                    let ctrl = AniMeZbus::new(anime);
+                    if ctrl
+                        .start_tasks(connection, path.clone())
+                        .await
+                        .map_err(|e| error!("Failed to start tasks: {e:?}, not adding this device"))
+                        .is_ok()
+                    {
+                        devices.push(AsusDevice {
+                            device: dev_type,
+                            dbus_path: path,
+                            hid_key: None,
+                        });
+                    }
+                }
+            } else {
+                info!("Tested device was not AniMe Matrix");
+            }
+        }
+
+        if do_kb_backlight {
+            // TUF AURA LAPTOP DEVICE
+            // product_name = ASUS TUF Gaming F15 FX507ZE_FX507ZE
+            // product_family = ASUS TUF Gaming F15
+            let product_name = DMIID::new().unwrap_or_default().product_name;
+            let product_family = DMIID::new().unwrap_or_default().product_family;
+            info!(
+                "No USB keyboard aura, system is {product_name}, try using sysfs backlight control"
+            );
+            if product_name.contains("TUF") || product_family.contains("TUF") {
+                info!("TUF laptop, try using sysfs backlight control");
+                if let Ok(dev_type) = DeviceHandle::maybe_laptop_aura(None, "tuf").await {
+                    if let DeviceHandle::Aura(aura) = dev_type.clone() {
+                        let path = dbus_path_for_tuf();
+                        let ctrl = AuraZbus::new(aura);
+                        ctrl.start_tasks(connection, path.clone()).await.unwrap();
+                        devices.push(AsusDevice {
+                            device: dev_type,
+                            dbus_path: path,
+                            hid_key: None,
+                        });
+                    }
+                }
+            }
+        }
+
+        if let Ok(devs) = &mut Self::init_all_scsi(connection).await {
+            devices.append(devs);
+        }
+
+        devices
+    }
+
+    pub async fn new(connection: Connection) -> Result<Self, RogError> {
+        let conn_copy = connection.clone();
+        let hid_handles = Arc::new(Mutex::new(HashMap::new()));
+        let devices = Self::find_all_devices(&conn_copy, hid_handles.clone()).await;
+        info!("Found {} valid devices on startup", devices.len());
+        let devices = Arc::new(Mutex::new(devices));
+        let manager = Self {
+            _dbus_connection: connection,
+            _hid_handles: hid_handles.clone(),
+        };
+
+        // TODO: The /sysfs/ LEDs don't cause events, so they need to be manually
+        // checked for and added
+
+        let hid_handles_thread = hid_handles.clone();
+        std::thread::spawn(move || {
+            let mut monitor = MonitorBuilder::new()?.listen()?;
+            let mut poll = Poll::new()?;
+            let mut events = Events::with_capacity(1024);
+            poll.registry()
+                .register(&mut monitor, Token(0), Interest::READABLE)?;
+
+            let rt = tokio::runtime::Runtime::new().expect("Unable to create Runtime");
+            let _enter = rt.enter();
+            loop {
+                if poll.poll(&mut events, None).is_err() {
+                    continue;
+                }
+                for event in monitor.iter() {
+                    let action = event
+                        .action()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .to_string();
+
+                    let subsys = if let Some(subsys) = event.subsystem() {
+                        subsys.to_string_lossy().to_string()
+                    } else {
+                        continue;
+                    };
+
+                    let devices = devices.clone();
+                    let conn_copy = conn_copy.clone();
+                    let hid_handles = hid_handles_thread.clone();
+                    block_on(async move {
+                        // SCSCI devs
+                        if subsys == "block" {
+                            if action == "remove" {
+                                if let Some(serial) =
+                                    event.device().property_value("ID_SERIAL_SHORT")
+                                {
+                                    let serial = serial.to_string_lossy().to_string();
+                                    let path = dbus_path_for_scsi(&serial);
+
+                                    let index = if let Some(index) = devices
+                                        .lock()
+                                        .await
+                                        .iter()
+                                        .position(|dev| dev.dbus_path == path)
+                                    {
+                                        index
+                                    } else {
+                                        if dev_prop_matches(&event.device(), "ID_VENDOR_ID", "0b05")
+                                        {
+                                            warn!("No device for dbus path: {path:?}");
+                                        }
+                                        return Ok(());
+                                    };
+                                    info!("removing: {path:?}");
+                                    let dev = devices.lock().await.remove(index);
+                                    let path = path.clone();
+                                    if let DeviceHandle::Scsi(_) = dev.device {
+                                        conn_copy
+                                            .object_server()
+                                            .remove::<ScsiZbus, _>(&path)
+                                            .await?;
+                                    }
+                                }
+                            } else if action == "add" {
+                                let evdev = event.device();
+                                if let Some(serial) = evdev.property_value("ID_SERIAL_SHORT") {
+                                    let serial = serial.to_string_lossy().to_string();
+                                    let path = dbus_path_for_scsi(&serial);
+                                    if let Some(new_devs) =
+                                        Self::init_scsi(&conn_copy, &evdev, path).await
+                                    {
+                                        devices.lock().await.append(&mut vec![new_devs]);
+                                    }
+                                }
+                            };
+                        }
+
+                        if subsys == "hidraw" {
+                            if let Some(parent) =
+                                event.parent_with_subsystem_devtype("usb", "usb_device")?
+                            {
+                                if action == "remove" {
+                                    if let Some(path) = dbus_path_for_dev(&parent) {
+                                        // Find the indexs of devices matching the path
+                                        let removals: Vec<usize> = devices
+                                            .lock()
+                                            .await
+                                            .iter()
+                                            .enumerate()
+                                            .filter_map(|(i, dev)| {
+                                                if dev.dbus_path == path {
+                                                    Some(i)
+                                                } else {
+                                                    None
+                                                }
+                                            })
+                                            .collect();
+                                        if removals.is_empty() {
+                                            return Ok(());
+                                        }
+                                        info!("removing: {path:?}");
+                                        // Iter in reverse so as to not screw up indexing
+                                        for index in removals.iter().rev() {
+                                            let dev = devices.lock().await.remove(*index);
+                                            let hid_key = dev.hid_key.clone();
+                                            let path = path.clone();
+                                            let res = match dev.device {
+                                                DeviceHandle::Aura(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<AuraZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::Slash(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<SlashZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::AniMe(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<AniMeZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                DeviceHandle::Scsi(_) => {
+                                                    conn_copy
+                                                        .object_server()
+                                                        .remove::<ScsiZbus, _>(&path)
+                                                        .await?
+                                                }
+                                                _ => todo!(),
+                                            };
+                                            info!("AuraManager removed: {path:?}, {res}");
+                                            if let Some(key) = hid_key {
+                                                hid_handles.lock().await.remove(&key);
+                                            }
+                                        }
+                                    }
+                                } else if action == "add" {
+                                    let evdev = event.device();
+                                    if let Ok(mut new_devs) = Self::init_hid_devices(
+                                        &conn_copy,
+                                        evdev,
+                                        hid_handles.clone(),
+                                    )
+                                    .await
+                                    .map_err(|e| error!("Couldn't add new device: {e:?}"))
+                                    {
+                                        devices.lock().await.append(&mut new_devs);
+                                    }
+                                };
+                            }
+                        }
+                        Ok::<(), RogError>(())
+                    })
+                    .map_err(|e| error!("{e:?}"))
+                    .ok();
+                }
+            }
+            // Required for return type on spawn
+            #[allow(unreachable_code)]
+            Ok::<(), RogError>(())
+        });
+        Ok(manager)
+    }
+}

asusd/src/aura_scsi/config.rs

@@ -0,0 +1,114 @@
+use std::collections::BTreeMap;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_aura::AuraDeviceType;
+use rog_scsi::{AuraEffect, AuraMode};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "scsi.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ScsiConfig {
+    #[serde(skip)]
+    pub dev_type: AuraDeviceType,
+    pub enabled: bool,
+    pub current_mode: AuraMode,
+    pub modes: BTreeMap<AuraMode, AuraEffect>,
+}
+
+impl ScsiConfig {
+    pub fn get_effect(&mut self, mode: AuraMode) -> Option<&AuraEffect> {
+        self.modes.get(&mode)
+    }
+
+    pub fn save_effect(&mut self, effect: AuraEffect) {
+        self.current_mode = effect.mode;
+        self.modes.insert(*effect.mode(), effect);
+    }
+}
+
+impl Default for ScsiConfig {
+    fn default() -> Self {
+        ScsiConfig {
+            enabled: true,
+            current_mode: AuraMode::Static,
+            dev_type: AuraDeviceType::ScsiExtDisk,
+            modes: BTreeMap::from([
+                (AuraMode::Off, AuraEffect::default_with_mode(AuraMode::Off)),
+                (
+                    AuraMode::Static,
+                    AuraEffect::default_with_mode(AuraMode::Static),
+                ),
+                (
+                    AuraMode::Breathe,
+                    AuraEffect::default_with_mode(AuraMode::Breathe),
+                ),
+                (
+                    AuraMode::Flashing,
+                    AuraEffect::default_with_mode(AuraMode::Flashing),
+                ),
+                (
+                    AuraMode::RainbowCycle,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycle),
+                ),
+                (
+                    AuraMode::RainbowWave,
+                    AuraEffect::default_with_mode(AuraMode::RainbowWave),
+                ),
+                (
+                    AuraMode::RainbowCycleBreathe,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleBreathe),
+                ),
+                (
+                    AuraMode::ChaseFade,
+                    AuraEffect::default_with_mode(AuraMode::ChaseFade),
+                ),
+                (
+                    AuraMode::RainbowCycleChaseFade,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleChaseFade),
+                ),
+                (
+                    AuraMode::Chase,
+                    AuraEffect::default_with_mode(AuraMode::Chase),
+                ),
+                (
+                    AuraMode::RainbowCycleChase,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleChase),
+                ),
+                (
+                    AuraMode::RainbowCycleWave,
+                    AuraEffect::default_with_mode(AuraMode::RainbowCycleWave),
+                ),
+                (
+                    AuraMode::RainbowPulseChase,
+                    AuraEffect::default_with_mode(AuraMode::RainbowPulseChase),
+                ),
+                (
+                    AuraMode::RandomFlicker,
+                    AuraEffect::default_with_mode(AuraMode::RandomFlicker),
+                ),
+                (
+                    AuraMode::DoubleFade,
+                    AuraEffect::default_with_mode(AuraMode::DoubleFade),
+                ),
+            ]),
+        }
+    }
+}
+
+impl StdConfig for ScsiConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for ScsiConfig {}

asusd/src/aura_scsi/mod.rs

@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use config::ScsiConfig;
+use rog_scsi::{AuraEffect, Device, Task};
+use tokio::sync::{Mutex, MutexGuard};
+
+use crate::error::RogError;
+
+pub mod config;
+pub mod trait_impls;
+
+#[derive(Clone)]
+pub struct ScsiAura {
+    device: Arc<Mutex<Device>>,
+    config: Arc<Mutex<ScsiConfig>>,
+}
+
+impl ScsiAura {
+    pub fn new(device: Arc<Mutex<Device>>, config: Arc<Mutex<ScsiConfig>>) -> Self {
+        Self { device, config }
+    }
+
+    pub async fn lock_config(&self) -> MutexGuard<'_, ScsiConfig> {
+        self.config.lock().await
+    }
+
+    pub async fn write_effect(&self, effect: &AuraEffect) -> Result<(), RogError> {
+        let tasks: Vec<Task> = effect.into();
+        for task in &tasks {
+            self.device.lock().await.perform(task).ok();
+        }
+        Ok(())
+    }
+
+    /// Initialise the device if required. Locks the internal config so be wary
+    /// of deadlocks.
+    pub async fn do_initialization(&self) -> Result<(), RogError> {
+        let config = self.config.lock().await;
+        let mode = config.current_mode;
+        if let Some(effect) = config.modes.get(&mode) {
+            self.write_effect(effect).await?;
+        }
+        Ok(())
+    }
+}

asusd/src/aura_scsi/trait_impls.rs

@@ -0,0 +1,116 @@
+use std::collections::BTreeMap;
+
+use config_traits::StdConfig;
+use log::error;
+use rog_aura::AuraDeviceType;
+use rog_scsi::{AuraEffect, AuraMode};
+use zbus::fdo::Error as ZbErr;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::ScsiAura;
+use crate::error::RogError;
+
+#[derive(Clone)]
+pub struct ScsiZbus(ScsiAura);
+
+impl ScsiZbus {
+    pub fn new(scsi: ScsiAura) -> Self {
+        Self(scsi)
+    }
+
+    pub async fn start_tasks(
+        self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+}
+
+#[interface(name = "xyz.ljones.ScsiAura")]
+impl ScsiZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        self.0.config.lock().await.dev_type
+    }
+
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock_config().await;
+        lock.enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut config = self.0.lock_config().await;
+        config.enabled = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn led_mode(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.current_mode as u8
+    }
+
+    #[zbus(property)]
+    async fn set_led_mode(&self, mode: AuraMode) -> Result<(), zbus::Error> {
+        let mut config = self.0.lock_config().await;
+        if let Some(effect) = config.get_effect(mode) {
+            self.0
+                .write_effect(effect)
+                .await
+                .map_err(|e| zbus::Error::Failure(format!("{e:?}")))?;
+        } else {
+            return Err(zbus::Error::Failure("Mode data does not exist".to_string()));
+        }
+        config.current_mode = mode;
+        config.write();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        // entirely possible to deadlock here, so use try instead of lock()
+        if let Ok(config) = self.0.config.try_lock() {
+            let mode = config.current_mode;
+            match config.modes.get(&mode) {
+                Some(effect) => Ok(effect.clone()),
+                None => Err(ZbErr::Failed("Could not get the current effect".into())),
+            }
+        } else {
+            Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        self.0.write_effect(&effect).await?;
+
+        let mut config = self.0.config.lock().await;
+        config.save_effect(effect);
+        config.write();
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraMode, AuraEffect> {
+        let config = self.0.config.lock().await;
+        config.modes.clone()
+    }
+}

asusd/src/aura_slash/config.rs

@@ -0,0 +1,66 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_slash::{DeviceState, SlashMode, SlashType};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "slash.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SlashConfig {
+    #[serde(skip)]
+    pub slash_type: SlashType,
+    pub enabled: bool,
+    pub brightness: u8,
+    pub display_interval: u8,
+    pub display_mode: SlashMode,
+    pub show_on_boot: bool,
+    pub show_on_shutdown: bool,
+    pub show_on_sleep: bool,
+    pub show_on_battery: bool,
+    pub show_battery_warning: bool,
+    pub show_on_lid_closed: bool,
+}
+
+impl Default for SlashConfig {
+    fn default() -> Self {
+        SlashConfig {
+            enabled: true,
+            brightness: 255,
+            display_interval: 0,
+            display_mode: SlashMode::Bounce,
+            slash_type: SlashType::Unsupported,
+            show_on_boot: true,
+            show_on_shutdown: true,
+            show_on_sleep: true,
+            show_on_battery: true,
+            show_battery_warning: true,
+            show_on_lid_closed: true,
+        }
+    }
+}
+impl StdConfig for SlashConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for SlashConfig {}
+
+impl From<&SlashConfig> for DeviceState {
+    fn from(config: &SlashConfig) -> Self {
+        DeviceState {
+            slash_enabled: config.enabled,
+            slash_brightness: config.brightness,
+            slash_interval: config.display_interval,
+            slash_mode: config.display_mode,
+        }
+    }
+}

asusd/src/aura_slash/mod.rs

@@ -0,0 +1,69 @@
+use std::sync::Arc;
+
+use config::SlashConfig;
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use rog_slash::usb::{slash_pkt_enable, slash_pkt_init, slash_pkt_options, slash_pkt_set_mode};
+use tokio::sync::{Mutex, MutexGuard};
+
+use crate::error::RogError;
+
+pub mod config;
+pub mod trait_impls;
+
+#[derive(Debug, Clone)]
+pub struct Slash {
+    hid: Option<Arc<Mutex<HidRaw>>>,
+    usb: Option<Arc<Mutex<USBRaw>>>,
+    config: Arc<Mutex<SlashConfig>>,
+}
+
+impl Slash {
+    pub fn new(
+        hid: Option<Arc<Mutex<HidRaw>>>,
+        usb: Option<Arc<Mutex<USBRaw>>>,
+        config: Arc<Mutex<SlashConfig>>,
+    ) -> Self {
+        Self { hid, usb, config }
+    }
+
+    pub async fn lock_config(&self) -> MutexGuard<'_, SlashConfig> {
+        self.config.lock().await
+    }
+
+    pub async fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        if let Some(hid) = &self.hid {
+            hid.lock().await.write_bytes(message)?;
+        } else if let Some(usb) = &self.usb {
+            usb.lock().await.write_bytes(message)?;
+        }
+        Ok(())
+    }
+
+    /// Initialise the device if required. Locks the internal config so be wary
+    /// of deadlocks.
+    pub async fn do_initialization(&self) -> Result<(), RogError> {
+        // Don't try to initialise these models as the asus drivers already did
+        let config = self.config.lock().await;
+        for pkt in &slash_pkt_init(config.slash_type) {
+            self.write_bytes(pkt).await?;
+        }
+        self.write_bytes(&slash_pkt_enable(config.slash_type, config.enabled))
+            .await?;
+
+        // Apply config upon initialization
+        let option_packets = slash_pkt_options(
+            config.slash_type,
+            config.enabled,
+            config.brightness,
+            config.display_interval,
+        );
+        self.write_bytes(&option_packets).await?;
+
+        let mode_packets = slash_pkt_set_mode(config.slash_type, config.display_mode);
+        // self.node.write_bytes(&mode_packets[0])?;
+        self.write_bytes(&mode_packets[1]).await?;
+
+        Ok(())
+    }
+}

asusd/src/aura_slash/trait_impls.rs

@@ -0,0 +1,317 @@
+use config_traits::StdConfig;
+use log::{debug, error, warn};
+use rog_slash::usb::{
+    slash_pkt_battery_saver, slash_pkt_boot, slash_pkt_enable, slash_pkt_lid_closed,
+    slash_pkt_low_battery, slash_pkt_options, slash_pkt_save, slash_pkt_set_mode,
+    slash_pkt_shutdown, slash_pkt_sleep,
+};
+use rog_slash::{DeviceState, SlashMode};
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::Slash;
+use crate::error::RogError;
+use crate::Reloadable;
+
+#[derive(Clone)]
+pub struct SlashZbus(Slash);
+
+impl SlashZbus {
+    pub fn new(slash: Slash) -> Self {
+        Self(slash)
+    }
+
+    pub async fn start_tasks(
+        mut self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        // let task = zbus.clone();
+        self.reload()
+            .await
+            .unwrap_or_else(|err| warn!("Controller error: {}", err));
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+}
+
+#[interface(name = "xyz.ljones.Slash")]
+impl SlashZbus {
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock_config().await;
+        lock.enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut config = self.0.lock_config().await;
+        let brightness = if enabled && config.brightness == 0 {
+            0x88
+        } else {
+            config.brightness
+        };
+        self.0
+            .write_bytes(&slash_pkt_enable(config.slash_type, enabled))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::enable {}", err);
+            })
+            .ok();
+        self.0
+            .write_bytes(&slash_pkt_options(
+                config.slash_type,
+                enabled,
+                brightness,
+                config.display_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.enabled = enabled;
+        config.brightness = brightness;
+        config.write();
+    }
+
+    /// Get brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.brightness
+    }
+
+    /// Set brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: u8) {
+        let mut config = self.0.lock_config().await;
+        let enabled = brightness > 0;
+        self.0
+            .write_bytes(&slash_pkt_options(
+                config.slash_type,
+                enabled,
+                brightness,
+                config.display_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.enabled = enabled;
+        config.brightness = brightness;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn interval(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.display_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_interval(&self, interval: u8) {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_options(
+                config.slash_type, config.enabled, config.brightness, interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.display_interval = interval;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn mode(&self) -> zbus::fdo::Result<u8> {
+        let config = self.0.lock_config().await;
+        Ok(config.display_interval)
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_mode(&self, mode: SlashMode) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+
+        let command_packets = slash_pkt_set_mode(config.slash_type, mode);
+        // self.node.write_bytes(&command_packets[0])?;
+        self.0.write_bytes(&command_packets[1]).await?;
+        self.0
+            .write_bytes(&slash_pkt_save(config.slash_type))
+            .await?;
+
+        config.display_mode = mode;
+        config.write();
+        Ok(())
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        let config = self.0.lock_config().await;
+        DeviceState::from(&*config)
+    }
+
+    #[zbus(property)]
+    async fn show_on_boot(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_boot)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_boot(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_boot(config.slash_type, enable))
+            .await?;
+        config.show_on_boot = enable;
+        config.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn show_on_sleep(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_sleep)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_sleep(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_sleep(config.slash_type, enable))
+            .await?;
+        config.show_on_sleep = enable;
+        config.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn show_on_shutdown(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_shutdown)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_shutdown(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_shutdown(config.slash_type, enable))
+            .await?;
+        config.show_on_shutdown = enable;
+        config.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn show_on_battery(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_battery)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_battery(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_battery_saver(config.slash_type, enable))
+            .await?;
+        config.show_on_battery = enable;
+        config.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn show_battery_warning(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_battery_warning)
+    }
+
+    #[zbus(property)]
+    async fn set_show_battery_warning(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_low_battery(config.slash_type, enable))
+            .await?;
+        config.show_battery_warning = enable;
+        config.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn show_on_lid_closed(&self) -> zbus::fdo::Result<bool> {
+        let config = self.0.lock_config().await;
+        Ok(config.show_on_lid_closed)
+    }
+
+    #[zbus(property)]
+    async fn set_show_on_lid_closed(&self, enable: bool) -> zbus::Result<()> {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_lid_closed(config.slash_type, enable))
+            .await?;
+        self.0
+            .write_bytes(&slash_pkt_save(config.slash_type))
+            .await?;
+        config.show_on_lid_closed = enable;
+        config.write();
+        Ok(())
+    }
+}
+
+impl Reloadable for SlashZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        debug!("reloading slash settings");
+        let config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&slash_pkt_options(
+                config.slash_type,
+                config.enabled,
+                config.brightness,
+                config.display_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("set_options {}", err);
+            })
+            .ok();
+
+        macro_rules! write_bytes_with_warning {
+            ($packet_fn:expr, $cfg:ident, $warn_msg:expr) => {
+                self.0
+                    .write_bytes(&$packet_fn(config.slash_type, config.$cfg))
+                    .await
+                    .map_err(|err| {
+                        warn!("{} {}", $warn_msg, err);
+                    })
+                    .ok();
+            };
+        }
+
+        write_bytes_with_warning!(slash_pkt_boot, show_on_boot, "show_on_boot");
+        write_bytes_with_warning!(slash_pkt_sleep, show_on_sleep, "show_on_sleep");
+        write_bytes_with_warning!(slash_pkt_shutdown, show_on_shutdown, "show_on_shutdown");
+        write_bytes_with_warning!(slash_pkt_battery_saver, show_on_battery, "show_on_battery");
+        write_bytes_with_warning!(
+            slash_pkt_low_battery,
+            show_battery_warning,
+            "show_battery_warning"
+        );
+
+        Ok(())
+    }
+}

asusd/src/aura_types.rs

@@ -0,0 +1,209 @@
+use std::sync::Arc;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{debug, error, info};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::get_anime_type;
+use rog_anime::AnimeType;
+use rog_aura::AuraDeviceType;
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardBacklight;
+use rog_platform::usb_raw::USBRaw;
+use rog_scsi::{open_device, ScsiType};
+use rog_slash::error::SlashError;
+use rog_slash::SlashType;
+use tokio::sync::Mutex;
+
+use crate::aura_anime::config::AniMeConfig;
+use crate::aura_anime::AniMe;
+use crate::aura_laptop::config::AuraConfig;
+use crate::aura_laptop::Aura;
+use crate::aura_scsi::config::ScsiConfig;
+use crate::aura_scsi::ScsiAura;
+use crate::aura_slash::config::SlashConfig;
+use crate::aura_slash::Slash;
+use crate::error::RogError;
+
+pub enum _DeviceHandle {
+    /// The AniMe devices require USBRaw as they are not HID devices
+    Usb(USBRaw),
+    HidRaw(HidRaw),
+    LedClass(KeyboardBacklight),
+    /// TODO
+    MulticolourLed,
+    None,
+}
+
+#[derive(Clone)]
+pub enum DeviceHandle {
+    Aura(Aura),
+    Slash(Slash),
+    /// The AniMe devices require USBRaw as they are not HID devices
+    AniMe(AniMe),
+    Scsi(ScsiAura),
+    Ally(Arc<Mutex<HidRaw>>),
+    OldAura(Arc<Mutex<HidRaw>>),
+    /// TUF laptops have an aditional set of attributes added to the LED /sysfs/
+    TufLedClass(Arc<Mutex<HidRaw>>),
+    /// TODO
+    MulticolourLed,
+    None,
+}
+
+impl DeviceHandle {
+    /// Try Slash HID. If one exists it is initialsed and returned.
+    pub async fn new_slash_hid(
+        device: Arc<Mutex<HidRaw>>,
+        prod_id: &str,
+    ) -> Result<Self, RogError> {
+        debug!("Testing for HIDRAW Slash");
+        let slash_type = SlashType::from_dmi();
+        if matches!(slash_type, SlashType::Unsupported)
+            || slash_type
+                .prod_id_str()
+                .to_lowercase()
+                .trim_start_matches("0x")
+                != prod_id
+        {
+            log::info!("Unknown or invalid slash: {prod_id:?}, skipping");
+            return Err(RogError::NotFound("No slash device".to_string()));
+        }
+        info!("Found slash type {slash_type:?}: {prod_id}");
+
+        let mut config = SlashConfig::new().load();
+        config.slash_type = slash_type;
+        let slash = Slash::new(Some(device), None, Arc::new(Mutex::new(config)));
+        slash.do_initialization().await?;
+        Ok(Self::Slash(slash))
+    }
+
+    /// Try Slash USB. If one exists it is initialsed and returned.
+    pub async fn new_slash_usb() -> Result<Self, RogError> {
+        debug!("Testing for USB Slash");
+        let slash_type = SlashType::from_dmi();
+        if matches!(slash_type, SlashType::Unsupported) {
+            return Err(RogError::Slash(SlashError::NoDevice));
+        }
+
+        if let Ok(usb) = USBRaw::new(slash_type.prod_id()) {
+            info!("Found Slash USB {slash_type:?}");
+
+            let mut config = SlashConfig::new().load();
+            config.slash_type = slash_type;
+            let slash = Slash::new(
+                None,
+                Some(Arc::new(Mutex::new(usb))),
+                Arc::new(Mutex::new(config)),
+            );
+            slash.do_initialization().await?;
+            Ok(Self::Slash(slash))
+        } else {
+            Err(RogError::NotFound("No slash device found".to_string()))
+        }
+    }
+
+    /// Try AniMe Matrix HID. If one exists it is initialsed and returned.
+    pub async fn maybe_anime_hid(
+        _device: Arc<Mutex<HidRaw>>,
+        _prod_id: &str,
+    ) -> Result<Self, RogError> {
+        // TODO: can't use HIDRAW for anime at the moment
+        Err(RogError::NotFound(
+            "Can't use anime over hidraw yet. Skip.".to_string(),
+        ))
+
+        // debug!("Testing for HIDRAW AniMe");
+        // let anime_type = AnimeType::from_dmi();
+        // dbg!(prod_id);
+        // if matches!(anime_type, AnimeType::Unsupported) || prod_id != "193b"
+        // {     log::info!("Unknown or invalid AniMe: {prod_id:?},
+        // skipping");     return Err(RogError::NotFound("No
+        // anime-matrix device".to_string())); }
+        // info!("Found AniMe Matrix HIDRAW {anime_type:?}: {prod_id}");
+
+        // let mut config = AniMeConfig::new().load();
+        // config.anime_type = anime_type;
+        // let mut anime = AniMe::new(Some(device), None,
+        // Arc::new(Mutex::new(config))); anime.do_initialization().
+        // await?; Ok(Self::AniMe(anime))
+    }
+
+    pub async fn maybe_anime_usb() -> Result<Self, RogError> {
+        debug!("Testing for USB AniMe");
+        let anime_type = get_anime_type();
+        if matches!(anime_type, AnimeType::Unsupported) {
+            info!("No Anime Matrix capable laptop found");
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        }
+
+        if let Ok(usb) = USBRaw::new(0x193b) {
+            info!("Found AniMe Matrix USB {anime_type:?}");
+
+            let mut config = AniMeConfig::new().load();
+            config.anime_type = anime_type;
+            let mut anime = AniMe::new(
+                None,
+                Some(Arc::new(Mutex::new(usb))),
+                Arc::new(Mutex::new(config)),
+            );
+            anime.do_initialization().await?;
+            Ok(Self::AniMe(anime))
+        } else {
+            Err(RogError::NotFound(
+                "No AnimeMatrix device found".to_string(),
+            ))
+        }
+    }
+
+    pub async fn maybe_scsi(dev_node: &str, prod_id: &str) -> Result<Self, RogError> {
+        debug!("Testing for SCSI");
+        let prod_id = ScsiType::from(prod_id);
+        if prod_id == ScsiType::Unsupported {
+            log::info!("Unknown or invalid SCSI: {prod_id:?}, skipping");
+            return Err(RogError::NotFound("No SCSI device".to_string()));
+        }
+        info!("Found SCSI device {prod_id:?} on {dev_node}");
+
+        let mut config = ScsiConfig::new().load();
+        config.dev_type = AuraDeviceType::ScsiExtDisk;
+        let dev = Arc::new(Mutex::new(open_device(dev_node)?));
+        let scsi = ScsiAura::new(dev, Arc::new(Mutex::new(config)));
+        scsi.do_initialization().await?;
+        Ok(Self::Scsi(scsi))
+    }
+
+    pub async fn maybe_laptop_aura(
+        device: Option<Arc<Mutex<HidRaw>>>,
+        prod_id: &str,
+    ) -> Result<Self, RogError> {
+        debug!("Testing for laptop aura");
+        let aura_type = AuraDeviceType::from(prod_id);
+        if !matches!(
+            aura_type,
+            AuraDeviceType::LaptopKeyboard2021
+                | AuraDeviceType::LaptopKeyboardPre2021
+                | AuraDeviceType::LaptopKeyboardTuf
+        ) {
+            log::info!("Unknown or invalid laptop aura: {prod_id:?}, skipping");
+            return Err(RogError::NotFound("No laptop aura device".to_string()));
+        }
+        info!("Found laptop aura type {prod_id:?}");
+
+        let backlight = KeyboardBacklight::new()
+            .map_err(|e| error!("Keyboard backlight error: {e:?}"))
+            .map_or(None, |k| {
+                info!("Found sysfs backlight control");
+                Some(Arc::new(Mutex::new(k)))
+            });
+
+        let mut config = AuraConfig::load_and_update_config(prod_id);
+        config.led_type = aura_type;
+        let aura = Aura {
+            hid: device,
+            backlight,
+            config: Arc::new(Mutex::new(config)),
+        };
+        aura.do_initialization().await?;
+        Ok(Self::Aura(aura))
+    }
+}

asusd/src/config.rs

@@ -0,0 +1,267 @@
+use std::collections::HashMap;
+
+use config_traits::{StdConfig, StdConfigLoad2};
+use rog_platform::asus_armoury::FirmwareAttribute;
+use rog_platform::cpu::CPUEPP;
+use rog_platform::platform::PlatformProfile;
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+/// Default value for base_charge_control_end_threshold when not present in config.
+/// Returns 0 so restore_charge_limit() skips restoration for upgraded configs.
+fn default_base_charge_limit() -> u8 {
+    0
+}
+
+#[derive(Default, Clone, Deserialize, Serialize, PartialEq)]
+pub struct Tuning {
+    pub enabled: bool,
+    pub group: HashMap<FirmwareAttribute, i32>,
+}
+type Tunings = HashMap<PlatformProfile, Tuning>;
+
+#[derive(Deserialize, Serialize, PartialEq)]
+pub struct Config {
+    // The current charge limit applied
+    pub charge_control_end_threshold: u8,
+    /// Save charge limit for restoring after one-shot full charge
+    #[serde(default = "default_base_charge_limit")]
+    pub base_charge_control_end_threshold: u8,
+    pub disable_nvidia_powerd_on_battery: bool,
+    /// An optional command/script to run when power is changed to AC
+    pub ac_command: String,
+    /// An optional command/script to run when power is changed to battery
+    pub bat_command: String,
+    /// Set true if energy_performance_preference should be set if the
+    /// platform profile is changed
+    pub platform_profile_linked_epp: bool,
+    /// Which platform profile to use on battery power
+    pub platform_profile_on_battery: PlatformProfile,
+    /// Should the throttle policy be set on bat/ac change?
+    pub change_platform_profile_on_battery: bool,
+    /// Which platform profile to use on AC power
+    pub platform_profile_on_ac: PlatformProfile,
+    /// Should the platform profile be set on bat/ac change?
+    pub change_platform_profile_on_ac: bool,
+    /// The energy_performance_preference for this platform profile
+    pub profile_quiet_epp: CPUEPP,
+    /// The energy_performance_preference for this platform profile
+    pub profile_balanced_epp: CPUEPP,
+    /// The energy_performance_preference for this platform profile
+    pub profile_custom_epp: CPUEPP,
+    /// The energy_performance_preference for this platform profile
+    pub profile_performance_epp: CPUEPP,
+    pub ac_profile_tunings: Tunings,
+    pub dc_profile_tunings: Tunings,
+    pub armoury_settings: HashMap<FirmwareAttribute, i32>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub screenpad_gamma: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub screenpad_sync_primary: Option<bool>,
+    /// Temporary state for AC/Batt
+    #[serde(skip)]
+    pub last_power_plugged: u8,
+}
+
+impl Config {
+    pub fn select_tunings(&mut self, power_plugged: bool, profile: PlatformProfile) -> &mut Tuning {
+        let config = if power_plugged {
+            &mut self.ac_profile_tunings
+        } else {
+            &mut self.dc_profile_tunings
+        };
+        config.entry(profile).or_insert_with(Tuning::default)
+    }
+
+    pub fn select_tunings_ref(
+        &self,
+        power_plugged: bool,
+        profile: PlatformProfile,
+    ) -> Option<&Tuning> {
+        let config = if power_plugged {
+            &self.ac_profile_tunings
+        } else {
+            &self.dc_profile_tunings
+        };
+        config.get(&profile)
+    }
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            charge_control_end_threshold: 100,
+            // NOTE: This is intentionally 100 (not 0 like the serde default).
+            // New installs get 100 (no limit). Upgraded configs missing this
+            // field get 0 via serde, which skips restore_charge_limit().
+            base_charge_control_end_threshold: 100,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: Default::default(),
+            bat_command: Default::default(),
+            platform_profile_linked_epp: true,
+            platform_profile_on_battery: PlatformProfile::Quiet,
+            change_platform_profile_on_battery: true,
+            platform_profile_on_ac: PlatformProfile::Performance,
+            change_platform_profile_on_ac: true,
+            profile_quiet_epp: CPUEPP::Power,
+            profile_balanced_epp: CPUEPP::BalancePower,
+            profile_performance_epp: CPUEPP::Performance,
+            profile_custom_epp: CPUEPP::Performance,
+            ac_profile_tunings: HashMap::default(),
+            dc_profile_tunings: HashMap::default(),
+            armoury_settings: HashMap::default(),
+            last_power_plugged: Default::default(),
+            screenpad_gamma: Default::default(),
+            screenpad_sync_primary: Default::default(),
+        }
+    }
+}
+
+impl StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            charge_control_end_threshold: 100,
+            disable_nvidia_powerd_on_battery: true,
+            platform_profile_on_battery: PlatformProfile::Quiet,
+            platform_profile_on_ac: PlatformProfile::Performance,
+            ac_command: String::new(),
+            bat_command: String::new(),
+            ..Default::default()
+        }
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad2<Config611, Config601> for Config {}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config611 {
+    pub charge_control_end_threshold: u8,
+    #[serde(skip)]
+    pub base_charge_control_end_threshold: u8,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+    pub platform_profile_linked_epp: bool,
+    pub platform_profile_on_battery: PlatformProfile,
+    pub change_platform_profile_on_battery: bool,
+    pub platform_profile_on_ac: PlatformProfile,
+    pub change_platform_profile_on_ac: bool,
+    pub profile_quiet_epp: CPUEPP,
+    pub profile_balanced_epp: CPUEPP,
+    pub profile_custom_epp: CPUEPP,
+    pub profile_performance_epp: CPUEPP,
+    pub ac_profile_tunings: Tunings,
+    pub dc_profile_tunings: Tunings,
+    pub armoury_settings: HashMap<FirmwareAttribute, i32>,
+    #[serde(skip)]
+    pub last_power_plugged: u8,
+}
+
+impl From<Config611> for Config {
+    fn from(c: Config611) -> Self {
+        let mut config = Self {
+            // Restore the base charge limit
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            base_charge_control_end_threshold: c.charge_control_end_threshold,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            platform_profile_linked_epp: c.platform_profile_linked_epp,
+            platform_profile_on_battery: c.platform_profile_on_battery,
+            change_platform_profile_on_battery: c.change_platform_profile_on_battery,
+            platform_profile_on_ac: c.platform_profile_on_ac,
+            change_platform_profile_on_ac: c.change_platform_profile_on_ac,
+            profile_quiet_epp: c.profile_quiet_epp,
+            profile_balanced_epp: c.profile_balanced_epp,
+            profile_performance_epp: c.profile_performance_epp,
+            profile_custom_epp: c.profile_performance_epp,
+            last_power_plugged: c.last_power_plugged,
+            ac_profile_tunings: HashMap::default(),
+            dc_profile_tunings: HashMap::default(),
+            armoury_settings: HashMap::default(),
+            screenpad_gamma: None,
+            screenpad_sync_primary: Default::default(),
+        };
+
+        config.ac_profile_tunings = c.ac_profile_tunings;
+        config.dc_profile_tunings = c.dc_profile_tunings;
+        config.armoury_settings = c.armoury_settings;
+        config
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config601 {
+    pub charge_control_end_threshold: u8,
+    #[serde(skip)]
+    pub base_charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub boot_sound: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+    pub platform_profile_linked_epp: bool,
+    pub platform_profile_on_battery: PlatformProfile,
+    pub change_platform_profile_on_battery: bool,
+    pub platform_profile_on_ac: PlatformProfile,
+    pub change_platform_profile_on_ac: bool,
+    pub profile_quiet_epp: CPUEPP,
+    pub profile_balanced_epp: CPUEPP,
+    pub profile_performance_epp: CPUEPP,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl1_spl: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl2_sppt: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl3_fppt: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_fppt: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_apu_sppt: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_platform_sppt: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_dynamic_boost: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_temp_target: Option<u8>,
+    #[serde(skip)]
+    pub last_power_plugged: u8,
+}
+
+impl From<Config601> for Config {
+    fn from(c: Config601) -> Self {
+        Self {
+            // Restore the base charge limit
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            base_charge_control_end_threshold: c.charge_control_end_threshold,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            platform_profile_linked_epp: c.platform_profile_linked_epp,
+            platform_profile_on_battery: c.platform_profile_on_battery,
+            change_platform_profile_on_battery: c.change_platform_profile_on_battery,
+            platform_profile_on_ac: c.platform_profile_on_ac,
+            change_platform_profile_on_ac: c.change_platform_profile_on_ac,
+            profile_quiet_epp: c.profile_quiet_epp,
+            profile_balanced_epp: c.profile_balanced_epp,
+            profile_performance_epp: c.profile_performance_epp,
+            profile_custom_epp: c.profile_performance_epp,
+            last_power_plugged: c.last_power_plugged,
+            ac_profile_tunings: HashMap::default(),
+            dc_profile_tunings: HashMap::default(),
+            armoury_settings: HashMap::default(),
+            screenpad_gamma: None,
+            screenpad_sync_primary: Default::default(),
+        }
+    }
+}

asusd/src/ctrl_backlight.rs

@@ -0,0 +1,348 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use config_traits::StdConfig;
+use log::{info, warn};
+use rog_platform::backlight::{Backlight, BacklightType};
+use tokio::sync::Mutex;
+use zbus::fdo::Error as FdoErr;
+use zbus::object_server::SignalEmitter;
+use zbus::{interface, Connection};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::ASUS_ZBUS_PATH;
+
+#[derive(Clone)]
+pub struct CtrlBacklight {
+    backlights: Vec<Backlight>,
+    config: Arc<Mutex<Config>>,
+}
+
+impl CtrlBacklight {
+    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
+        let mut backlights = Vec::new();
+
+        if let Ok(primary) = Backlight::new(BacklightType::Primary) {
+            info!("Found primary display backlight");
+            backlights.push(primary);
+        }
+
+        if let Ok(screenpad) = Backlight::new(BacklightType::Screenpad) {
+            info!("Found screenpad backlight");
+            backlights.push(screenpad);
+        }
+
+        if backlights.is_empty() {
+            return Err(RogError::MissingFunction("No backlights found".into()));
+        }
+
+        Ok(Self { backlights, config })
+    }
+
+    fn get_backlight(&self, device_type: &BacklightType) -> Option<&Backlight> {
+        self.backlights
+            .iter()
+            .find(|b| b.device_type() == device_type)
+    }
+
+    async fn set_brightness_with_sync(
+        &self,
+        device_type: &BacklightType,
+        level: i32,
+    ) -> Result<(), FdoErr> {
+        let sync = self
+            .config
+            .lock()
+            .await
+            .screenpad_sync_primary
+            .unwrap_or_default();
+
+        // If sync is enabled and we're setting screenpad brightness, set primary first
+        if sync && *device_type == BacklightType::Screenpad {
+            if let Some(primary) = self.get_backlight(&BacklightType::Primary) {
+                if let Ok(primary_max) = primary.get_max_brightness() {
+                    let primary_scaled = level * primary_max / 100;
+                    let _ = primary.set_brightness(primary_scaled);
+                }
+            }
+        }
+
+        if let Some(backlight) = self.get_backlight(device_type) {
+            let max = backlight.get_max_brightness().map_err(|e| {
+                warn!("Failed to get max brightness: {}", e);
+                FdoErr::Failed(format!("Failed to get max brightness: {}", e))
+            })?;
+
+            let gamma = self.config.lock().await.screenpad_gamma.unwrap_or(1.0);
+            let scaled = if *device_type == BacklightType::Screenpad {
+                // Apply non-linear scaling with the configurable gamma value only for Screenpad
+                let normalized_level = level as f32 / 100.0;
+                let gamma_corrected = normalized_level.powf(gamma);
+                (gamma_corrected * max as f32) as i32
+            } else {
+                // Linear scaling for other devices
+                level * max / 100
+            };
+
+            backlight.set_brightness(scaled).map_err(|e| {
+                warn!("Failed to set brightness: {}", e);
+                FdoErr::Failed(format!("Failed to set brightness: {}", e))
+            })?;
+
+            // If sync is enabled and we're setting primary brightness, set screenpad
+            // afterward
+            if sync && *device_type == BacklightType::Primary {
+                for other in self
+                    .backlights
+                    .iter()
+                    .filter(|b| b.device_type() != device_type)
+                {
+                    if let Ok(other_max) = other.get_max_brightness() {
+                        let other_scaled = if other.device_type() == &BacklightType::Screenpad {
+                            // Apply gamma only to Screenpad
+                            let normalized_level = level as f32 / 100.0;
+                            let gamma_corrected = normalized_level.powf(gamma);
+                            (gamma_corrected * other_max as f32) as i32
+                        } else {
+                            // Linear scaling for other devices
+                            level * other_max / 100
+                        };
+                        let _ = other.set_brightness(other_scaled);
+                    }
+                }
+            }
+
+            Ok(())
+        } else {
+            Err(FdoErr::NotSupported(format!(
+                "Backlight {:?} not found",
+                device_type
+            )))
+        }
+    }
+
+    async fn get_brightness_percent(&self, device_type: &BacklightType) -> Result<i32, FdoErr> {
+        if let Some(backlight) = self.get_backlight(device_type) {
+            let brightness = backlight.get_brightness().map_err(|e| {
+                warn!("Failed to get brightness: {}", e);
+                FdoErr::Failed(format!("Failed to get brightness: {}", e))
+            })?;
+
+            let max = backlight.get_max_brightness().map_err(|e| {
+                warn!("Failed to get max brightness: {}", e);
+                FdoErr::Failed(format!("Failed to get max brightness: {}", e))
+            })?;
+
+            if *device_type == BacklightType::Screenpad {
+                let gamma = self.config.lock().await.screenpad_gamma.unwrap_or(1.0);
+                let normalized = brightness as f32 / max as f32;
+                let corrected = normalized.powf(1.0 / gamma);
+                Ok((corrected * 100.0).round() as i32)
+            } else {
+                Ok(brightness * 100 / max)
+            }
+        } else {
+            Err(FdoErr::NotSupported(format!(
+                "Backlight {:?} not found",
+                device_type
+            )))
+        }
+    }
+
+    pub async fn start_watch_primary(&self) -> Result<(), RogError> {
+        if self.get_backlight(&BacklightType::Screenpad).is_none() {
+            return Ok(());
+        }
+
+        if let Some(sync) = self.config.lock().await.screenpad_sync_primary {
+            if !sync {
+                return Ok(());
+            }
+        }
+
+        if let Some(backlight) = self.get_backlight(&BacklightType::Primary) {
+            let watch = backlight.monitor_brightness()?;
+
+            let backlights = self.clone();
+            tokio::spawn(async move {
+                let mut last_level = 0;
+                let mut buffer = [0; 32];
+                use futures_lite::StreamExt;
+                if let Ok(mut stream) = watch.into_event_stream(&mut buffer) {
+                    loop {
+                        let _ = stream.next().await;
+
+                        let sync = backlights.config.lock().await.screenpad_sync_primary;
+                        if let Some(sync) = sync {
+                            if !sync {
+                                continue;
+                            }
+                        } else if backlights
+                            .config
+                            .lock()
+                            .await
+                            .screenpad_sync_primary
+                            .is_none()
+                        {
+                            continue;
+                        }
+
+                        let level = backlights
+                            .get_brightness_percent(&BacklightType::Primary)
+                            .await
+                            .unwrap_or(60);
+                        if last_level != level {
+                            last_level = level;
+                            backlights
+                                .set_brightness_with_sync(&BacklightType::Screenpad, level)
+                                .await
+                                .ok();
+                        }
+
+                        // other processes cause "MODIFY" event and make this spin 100%, so sleep
+                        tokio::time::sleep(Duration::from_millis(300)).await;
+                    }
+                    // watch
+                    //     .into_event_stream(&mut buffer)
+                    //     .unwrap()
+                    //     .for_each(|_| async {})
+                    //     .await;
+                }
+            });
+        }
+
+        Ok(())
+    }
+}
+
+#[interface(name = "xyz.ljones.Backlight")]
+impl CtrlBacklight {
+    #[zbus(property)]
+    async fn screenpad_sync_with_primary(&self) -> bool {
+        self.config
+            .lock()
+            .await
+            .screenpad_sync_primary
+            .unwrap_or_default()
+    }
+
+    #[zbus(property)]
+    async fn set_screenpad_sync_with_primary(&self, sync: bool) -> Result<(), zbus::Error> {
+        self.config.lock().await.screenpad_sync_primary = Some(sync);
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn screenpad_gamma(&self) -> String {
+        (self.config.lock().await.screenpad_gamma.unwrap_or(1.0)).to_string()
+    }
+
+    #[zbus(property)]
+    async fn set_screenpad_gamma(&self, value: &str) -> Result<(), zbus::Error> {
+        let gamma: f32 = value
+            .parse()
+            .map_err(|_| FdoErr::Failed("Invalid gamma value, must be a valid number".into()))?;
+
+        if gamma < 0.1 {
+            return Err(FdoErr::Failed("Gamma value must be greater than 0".into()).into());
+        }
+        if gamma > 2.0 {
+            return Err(FdoErr::Failed("Gamma value must be 2.0 or less".into()).into());
+        }
+        self.config.lock().await.screenpad_gamma = Some(gamma);
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn primary_brightness(&self) -> Result<i32, FdoErr> {
+        self.get_brightness_percent(&BacklightType::Primary).await
+    }
+
+    #[zbus(property)]
+    async fn set_primary_brightness(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        level: i32,
+    ) -> Result<(), zbus::Error> {
+        if level > 100 {
+            return Err(FdoErr::Failed("Brightness level must be 0-100".into()).into());
+        }
+
+        self.set_brightness_with_sync(&BacklightType::Primary, level)
+            .await?;
+        self.primary_brightness_changed(&ctxt).await?;
+
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn screenpad_brightness(&self) -> Result<i32, FdoErr> {
+        self.get_brightness_percent(&BacklightType::Screenpad).await
+    }
+
+    #[zbus(property)]
+    async fn set_screenpad_brightness(
+        &self,
+        // #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        level: i32,
+    ) -> Result<(), zbus::Error> {
+        if level > 100 {
+            return Err(FdoErr::Failed("Brightness level must be 0-100".into()).into());
+        }
+
+        self.set_brightness_with_sync(&BacklightType::Screenpad, level)
+            .await?;
+        // self.screenpad_brightness_changed(&ctxt).await?;
+
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn screenpad_power(&self) -> Result<bool, FdoErr> {
+        if let Some(backlight) = self.get_backlight(&BacklightType::Screenpad) {
+            let power = backlight.get_bl_power().map_err(|e| {
+                warn!("Failed to get backlight power: {}", e);
+                FdoErr::Failed(format!("Failed to get backlight power: {}", e))
+            })?;
+            Ok(power == 0)
+        } else {
+            Err(FdoErr::NotSupported("Screenpad backlight not found".into()))
+        }
+    }
+
+    #[zbus(property)]
+    async fn set_screenpad_power(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        power: bool,
+    ) -> Result<(), zbus::Error> {
+        if let Some(backlight) = self.get_backlight(&BacklightType::Screenpad) {
+            backlight
+                .set_bl_power(if power { 0 } else { 1 })
+                .map_err(|e| {
+                    warn!("Failed to set backlight power: {}", e);
+                    FdoErr::Failed(format!("Failed to set backlight power: {}", e))
+                })?;
+            self.screenpad_power_changed(&ctxt).await?;
+            Ok(())
+        } else {
+            Err(FdoErr::NotSupported("Screenpad backlight not found".into()).into())
+        }
+    }
+}
+
+impl crate::ZbusRun for CtrlBacklight {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ASUS_ZBUS_PATH, server).await;
+    }
+}
+
+impl crate::Reloadable for CtrlBacklight {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        info!("Reloading backlight settings");
+        Ok(())
+    }
+}

asusd/src/ctrl_fancurves.rs

@@ -0,0 +1,289 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use futures_lite::StreamExt;
+use log::{debug, error, info, warn};
+use rog_platform::platform::{PlatformProfile, RogPlatform};
+use rog_profiles::error::ProfileError;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use zbus::object_server::SignalEmitter;
+use zbus::{interface, Connection};
+
+use crate::error::RogError;
+use crate::{CtrlTask, CONFIG_PATH_BASE};
+
+pub const FAN_CURVE_ZBUS_NAME: &str = "FanCurves";
+pub const FAN_CURVE_ZBUS_PATH: &str = "/xyz/ljones";
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub profiles: FanCurveProfiles,
+    #[serde(skip)]
+    pub current: PlatformProfile,
+}
+
+impl StdConfig for FanCurveConfig {
+    /// Create a new config. The defaults are zeroed so the device must be read
+    /// to get the actual device defaults.
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        "fan_curves.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for FanCurveConfig {}
+
+#[derive(Debug, Clone)]
+pub struct CtrlFanCurveZbus {
+    config: Arc<Mutex<FanCurveConfig>>,
+    platform: RogPlatform,
+}
+
+// Non-zbus-derive impl
+impl CtrlFanCurveZbus {
+    pub fn new() -> Result<Self, RogError> {
+        let platform = RogPlatform::new()?;
+        if platform.has_platform_profile() {
+            info!("Device has profile control available");
+            find_fan_curve_node()?;
+            info!("Device has fan curves available");
+            let mut config = FanCurveConfig::new().load();
+            let mut fan_curves = FanCurveProfiles::default();
+
+            // Only do defaults if the config doesn't already exist\
+            if config.profiles.balanced.is_empty() || !config.file_path().exists() {
+                info!("Fetching default fan curves");
+
+                let current = platform.get_platform_profile()?;
+                let profiles = platform.get_platform_profile_choices()?;
+                for this in profiles {
+                    // For each profile we need to switch to it before we
+                    // can read the existing values from hardware. The ACPI method used
+                    // for this is what limits us.
+                    platform.set_platform_profile(this.into())?;
+                    let mut dev = find_fan_curve_node()?;
+                    fan_curves.set_active_curve_to_defaults(this, &mut dev)?;
+
+                    info!("{this:?}:");
+                    for curve in fan_curves.get_fan_curves_for(this) {
+                        info!("{}", String::from(curve));
+                    }
+                }
+                platform.set_platform_profile(current.as_str())?;
+                config.profiles = fan_curves;
+                config.write();
+            } else {
+                info!("Fan curves previously stored, loading...");
+                config = config.load();
+            }
+
+            return Ok(Self {
+                config: Arc::new(Mutex::new(config)),
+                platform,
+            });
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+}
+
+#[interface(name = "xyz.ljones.FanCurves")]
+impl CtrlFanCurveZbus {
+    /// Set all fan curves for a profile to enabled status. Will also activate a
+    /// fan curve if in the same profile mode
+    async fn set_fan_curves_enabled(
+        &mut self,
+        profile: PlatformProfile,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_curves_enabled(profile, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Set a single fan curve for a profile to enabled status. Will also
+    /// activate a fan curve if in the same profile mode
+    async fn set_profile_fan_curve_enabled(
+        &mut self,
+        profile: PlatformProfile,
+        fan: FanCurvePU,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_fan_curve_enabled(profile, fan, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Get the fan-curve data for the currently active ThrottlePolicy
+    async fn fan_curve_data(
+        &mut self,
+        profile: PlatformProfile,
+    ) -> zbus::fdo::Result<Vec<CurveData>> {
+        let curve = self
+            .config
+            .lock()
+            .await
+            .profiles
+            .get_fan_curves_for(profile)
+            .to_vec();
+        Ok(curve)
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    async fn set_fan_curve(
+        &mut self,
+        profile: PlatformProfile,
+        curve: CurveData,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .save_fan_curve(curve, profile)?;
+        let active: PlatformProfile = self.platform.get_platform_profile()?.into();
+        if active == profile {
+            self.config
+                .lock()
+                .await
+                .profiles
+                .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        }
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curves to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the default can be
+    /// read only for the currently active profile.
+    async fn set_curves_to_defaults(&mut self, profile: PlatformProfile) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_platform_profile()?;
+        self.platform.set_platform_profile(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(profile, &mut find_fan_curve_node()?)?;
+        self.platform.set_platform_profile(active.as_str())?;
+        self.config.lock().await.write();
+        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.
+    async fn reset_profile_curves(&self, profile: PlatformProfile) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_platform_profile()?;
+
+        self.platform.set_platform_profile(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(active.as_str().into(), &mut find_fan_curve_node()?)?;
+        self.platform.set_platform_profile(active.as_str())?;
+
+        self.config.lock().await.write();
+        Ok(())
+    }
+}
+
+impl crate::ZbusRun for CtrlFanCurveZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, FAN_CURVE_ZBUS_PATH, server).await;
+    }
+}
+
+impl CtrlTask for CtrlFanCurveZbus {
+    fn zbus_path() -> &'static str {
+        FAN_CURVE_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _signal_ctxt: SignalEmitter<'static>) -> Result<(), RogError> {
+        let watch_platform_profile = self.platform.monitor_platform_profile()?;
+        let platform = self.platform.clone();
+        let config = self.config.clone();
+        let fan_curves = self.config.clone();
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            if let Ok(mut stream) = watch_platform_profile.into_event_stream(&mut buffer) {
+                while (stream.next().await).is_some() {
+                    debug!("watch_platform_profile changed");
+                    if let Ok(profile) =
+                        platform
+                            .get_platform_profile()
+                            .map(|p| p.into())
+                            .map_err(|e| {
+                                error!("get_platform_profile error: {e}");
+                            })
+                    {
+                        if profile != config.lock().await.current {
+                            fan_curves
+                                .lock()
+                                .await
+                                .profiles
+                                .write_profile_curve_to_platform(
+                                    profile,
+                                    &mut find_fan_curve_node().unwrap(),
+                                )
+                                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                                .ok();
+                            config.lock().await.current = profile;
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlFanCurveZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let active = self.platform.get_platform_profile()?.into();
+        let mut config = self.config.lock().await;
+        if let Ok(mut device) = find_fan_curve_node() {
+            config
+                .profiles
+                .write_profile_curve_to_platform(active, &mut device)?;
+        }
+
+        Ok(())
+    }
+}

asusd/src/ctrl_platform.rs

@@ -0,0 +1,934 @@
+use std::path::Path;
+use std::process::Command;
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_platform::asus_armoury::{AttrValue, FirmwareAttribute, FirmwareAttributes};
+use rog_platform::cpu::{CPUControl, CPUGovernor, CPUEPP};
+use rog_platform::platform::{PlatformProfile, Properties, RogPlatform};
+use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
+use zbus::fdo::Error as FdoErr;
+use zbus::object_server::SignalEmitter;
+use zbus::{interface, Connection};
+
+use crate::asus_armoury::{set_config_or_default, ArmouryAttributeRegistry};
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{task_watch_item, CtrlTask, ReloadAndNotify};
+
+const PLATFORM_ZBUS_PATH: &str = "/xyz/ljones";
+
+macro_rules! platform_get_value {
+    ($self:ident, $property:tt, $prop_name:literal) => {
+        concat_idents::concat_idents!(has = has_, $property {
+            if $self.platform.has() {
+                concat_idents::concat_idents!(get = get_, $property {
+                    $self.platform
+                    .get()
+                    .map_err(|err| {
+                        warn!("{}: {}", $prop_name, err);
+                        FdoErr::Failed(format!("RogPlatform: {}: {}", $prop_name, err))
+                    })
+                })
+            } else {
+                return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+            }
+        })
+    }
+}
+
+#[derive(Clone)]
+pub struct CtrlPlatform {
+    power: AsusPower,
+    platform: RogPlatform,
+    attributes: FirmwareAttributes,
+    cpu_control: Option<CPUControl>,
+    config: Arc<Mutex<Config>>,
+    connection: Connection,
+    armoury_registry: ArmouryAttributeRegistry,
+}
+
+impl CtrlPlatform {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        platform: RogPlatform,
+        power: AsusPower,
+        attributes: FirmwareAttributes,
+        config: Arc<Mutex<Config>>,
+        config_path: &Path,
+        signal_context: SignalEmitter<'static>,
+        connection: Connection,
+        armoury_registry: ArmouryAttributeRegistry,
+    ) -> Result<Self, RogError> {
+        let config1 = config.clone();
+        let config_path = config_path.to_owned();
+
+        let ret_self = CtrlPlatform {
+            power,
+            platform,
+            attributes,
+            config,
+            cpu_control: CPUControl::new()
+                .map_err(|e| error!("Couldn't get CPU control sysfs: {e}"))
+                .ok(),
+            connection,
+            armoury_registry,
+        };
+        let mut inotify_self = ret_self.clone();
+
+        tokio::spawn(async move {
+            use futures_util::StreamExt;
+            info!("Starting inotify watch for asusd config file");
+
+            let mut buffer = [0; 32];
+            loop {
+                // vi and vim do stupid shit causing the file watch to be removed
+                let inotify = inotify::Inotify::init().unwrap();
+                inotify
+                    .watches()
+                    .add(
+                        &config_path,
+                        inotify::WatchMask::MODIFY
+                            | inotify::WatchMask::CLOSE_WRITE
+                            | inotify::WatchMask::ATTRIB
+                            | inotify::WatchMask::CREATE,
+                    )
+                    .inspect_err(|e| {
+                        if e.kind() == std::io::ErrorKind::NotFound {
+                            error!("Not found: {:?}", config_path);
+                        } else {
+                            error!("Could not set asusd config inotify: {:?}", config_path);
+                        }
+                    })
+                    .ok();
+                let mut events = inotify.into_event_stream(&mut buffer).unwrap();
+
+                while let Some(ev) = events.next().await {
+                    if let Ok(ev) = ev {
+                        if ev.mask == inotify::EventMask::IGNORED {
+                            warn!(
+                                "Something modified asusd.ron vi/vim style. Now need to reload \
+                                 inotify watch"
+                            );
+                            break;
+                        }
+                    }
+
+                    let res = config1.lock().await.read_new();
+                    if let Some(new_cfg) = res {
+                        inotify_self
+                            .reload_and_notify(&signal_context, new_cfg)
+                            .await
+                            .unwrap();
+                    }
+                }
+            }
+        });
+
+        Ok(ret_self)
+    }
+
+    async fn restore_charge_limit(&self) {
+        let limit = self.config.lock().await.base_charge_control_end_threshold;
+        if limit > 0
+            && std::mem::replace(
+                &mut self.config.lock().await.charge_control_end_threshold,
+                limit,
+            ) != limit
+        {
+            self.power
+                .set_charge_control_end_threshold(limit)
+                .map_err(|e| {
+                    error!("Couldn't restore charge limit: {e}");
+                })
+                .ok();
+            self.config.lock().await.write();
+        }
+    }
+
+    async fn run_ac_or_bat_cmd(&self, power_plugged: bool) {
+        let prog: Vec<String> = if power_plugged {
+            // AC ONLINE
+            self.config
+                .lock()
+                .await
+                .ac_command
+                .split_whitespace()
+                .map(|s| s.to_string())
+                .collect()
+        } else {
+            // BATTERY
+            self.config
+                .lock()
+                .await
+                .bat_command
+                .split_whitespace()
+                .map(|s| s.to_string())
+                .collect()
+        };
+        if (!prog.is_empty()) && (!prog[0].is_empty()) {
+            let mut cmd = Command::new(&prog[0]);
+            for arg in prog.iter().skip(1) {
+                cmd.arg(arg);
+            }
+            if let Err(e) = cmd.spawn() {
+                if power_plugged {
+                    error!("AC power command error: {e}");
+                } else {
+                    error!("Battery power command error: {e}");
+                }
+            }
+        }
+    }
+
+    fn check_and_set_epp(&self, enegy_pref: CPUEPP, change_epp: bool) {
+        if !change_epp {
+            info!("ThrottlePolicy unlinked from EPP");
+            return;
+        }
+        info!("ThrottlePolicy setting EPP");
+        if let Some(cpu) = self.cpu_control.as_ref() {
+            if let Ok(epp) = cpu.get_available_epp() {
+                debug!("Available EPP: {epp:?}");
+                if epp.contains(&enegy_pref) {
+                    debug!("Setting {enegy_pref:?}");
+                    cpu.set_epp(enegy_pref).ok();
+                } else if let Ok(gov) = cpu.get_governor() {
+                    if gov != CPUGovernor::Powersave {
+                        warn!("powersave governor is not is use, trying to set.");
+                        cpu.set_governor(CPUGovernor::Powersave)
+                            .map_err(|e| error!("couldn't set powersave: {e:?}"))
+                            .ok();
+                        if epp.contains(&enegy_pref) {
+                            debug!("Setting {enegy_pref:?}");
+                            cpu.set_epp(enegy_pref)
+                                .map_err(|e| error!("couldn't set EPP: {e:?}"))
+                                .ok();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    async fn get_config_epp_for_throttle(&self, throttle: PlatformProfile) -> CPUEPP {
+        match throttle {
+            PlatformProfile::Balanced => self.config.lock().await.profile_balanced_epp,
+            PlatformProfile::Performance => self.config.lock().await.profile_performance_epp,
+            PlatformProfile::Quiet => self.config.lock().await.profile_quiet_epp,
+            PlatformProfile::LowPower => self.config.lock().await.profile_quiet_epp,
+            PlatformProfile::Custom => self.config.lock().await.profile_custom_epp,
+        }
+    }
+
+    async fn update_policy_ac_or_bat(&self, power_plugged: bool, change_epp: bool) {
+        if power_plugged && !self.config.lock().await.change_platform_profile_on_ac {
+            debug!(
+                "Power status changed but set_platform_profile_on_ac set false. Not setting the \
+                 thing"
+            );
+            return;
+        }
+        if !power_plugged && !self.config.lock().await.change_platform_profile_on_battery {
+            debug!(
+                "Power status changed but set_platform_profile_on_battery set false. Not setting \
+                 the thing"
+            );
+            return;
+        }
+
+        let throttle = if power_plugged {
+            self.config.lock().await.platform_profile_on_ac
+        } else {
+            self.config.lock().await.platform_profile_on_battery
+        };
+        debug!("Setting {throttle:?} before EPP");
+        let epp = self.get_config_epp_for_throttle(throttle).await;
+        self.platform.set_platform_profile(throttle.into()).ok();
+        self.check_and_set_epp(epp, change_epp);
+    }
+}
+
+#[interface(name = "xyz.ljones.Platform")]
+impl CtrlPlatform {
+    #[zbus(property)]
+    async fn version(&self) -> String {
+        crate::VERSION.to_string()
+    }
+
+    /// Returns a list of property names that this system supports
+    async fn supported_properties(&self) -> Vec<Properties> {
+        let mut supported = Vec::new();
+
+        macro_rules! platform_name {
+            ($property:tt, $prop_name:ty) => {
+                concat_idents::concat_idents!(has = has_, $property {
+                    if self.platform.has() {
+                        supported.push($prop_name.to_owned());
+                    }
+                })
+            }
+        }
+
+        macro_rules! power_name {
+            ($property:tt, $prop_name:ty) => {
+                concat_idents::concat_idents!(has = has_, $property {
+                    if self.power.has() {
+                        supported.push($prop_name.to_owned());
+                    }
+                })
+            }
+        }
+
+        // TODO: automate this
+        power_name!(
+            charge_control_end_threshold,
+            Properties::ChargeControlEndThreshold
+        );
+
+        platform_name!(platform_profile, Properties::ThrottlePolicy);
+
+        supported
+    }
+
+    #[zbus(property)]
+    fn charge_control_end_threshold(&self) -> Result<u8, FdoErr> {
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
+        let limit = self.power.get_charge_control_end_threshold().map_err(|e| {
+            FdoErr::Failed(format!(
+                "Could not read charge_control_end_threshold: {e:?}"
+            ))
+        })?;
+
+        Ok(limit)
+    }
+
+    #[zbus(property)]
+    async fn set_charge_control_end_threshold(&mut self, limit: u8) -> Result<(), FdoErr> {
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit))?;
+        }
+
+        self.power
+            .set_charge_control_end_threshold(limit)
+            .map_err(|e| {
+                FdoErr::Failed(format!("Could not set charge_control_end_threshold: {e:?}"))
+            })?;
+
+        self.config.lock().await.charge_control_end_threshold = limit;
+        self.config.lock().await.base_charge_control_end_threshold = limit;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    async fn one_shot_full_charge(&self) -> Result<(), FdoErr> {
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
+        let base_limit = std::mem::replace(
+            &mut self.config.lock().await.charge_control_end_threshold,
+            100,
+        );
+        if base_limit != 100 {
+            self.power
+                .set_charge_control_end_threshold(100)
+                .map_err(|e| {
+                    FdoErr::Failed(format!("Could not set one_shot_full_charge: {e:?}"))
+                })?;
+            self.config.lock().await.base_charge_control_end_threshold = base_limit;
+            self.config.lock().await.write();
+        }
+        Ok(())
+    }
+
+    /// 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_platform_profile(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+    ) -> Result<(), FdoErr> {
+        let policy: PlatformProfile =
+            platform_get_value!(self, platform_profile, "platform_profile").map(|n| n.into())?;
+        let choices =
+            platform_get_value!(self, platform_profile_choices, "platform_profile_choices")?;
+        let policy = PlatformProfile::next(policy, &choices);
+
+        if self.platform.has_platform_profile() {
+            let change_epp = self.config.lock().await.platform_profile_linked_epp;
+            let epp = self.get_config_epp_for_throttle(policy).await;
+            self.check_and_set_epp(epp, change_epp);
+            self.platform
+                .set_platform_profile(policy.into())
+                .map_err(|err| {
+                    warn!("platform_profile {}", err);
+                    FdoErr::Failed(format!("RogPlatform: platform_profile: {err}"))
+                })?;
+            self.enable_ppt_group_changed(&ctxt).await?;
+            Ok(self.platform_profile_changed(&ctxt).await?)
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: platform_profile not supported".to_owned(),
+            ))
+        }
+    }
+
+    #[zbus(property)]
+    fn platform_profile_choices(&self) -> Result<Vec<PlatformProfile>, FdoErr> {
+        platform_get_value!(self, platform_profile_choices, "platform_profile_choices")
+    }
+
+    #[zbus(property)]
+    fn platform_profile(&self) -> Result<PlatformProfile, FdoErr> {
+        let policy: PlatformProfile = self.platform.get_platform_profile()?.as_str().into();
+        Ok(policy)
+    }
+
+    #[zbus(property)]
+    async fn set_platform_profile(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        policy: PlatformProfile,
+    ) -> Result<(), FdoErr> {
+        // TODO: watch for external changes
+        if self.platform.has_platform_profile() {
+            let change_epp = self.config.lock().await.platform_profile_linked_epp;
+            let epp = self.get_config_epp_for_throttle(policy).await;
+            self.check_and_set_epp(epp, change_epp);
+
+            self.config.lock().await.write();
+
+            let choices = self.platform.get_platform_profile_choices()?;
+            if !choices.contains(&policy) {
+                return Err(FdoErr::NotSupported(format!(
+                    "RogPlatform: platform_profile: {} not supported",
+                    policy
+                )));
+            }
+
+            self.platform
+                .set_platform_profile(policy.into())
+                .map_err(|err| {
+                    warn!("platform_profile {}", err);
+                    FdoErr::Failed(format!("RogPlatform: platform_profile: {err}"))
+                })?;
+            self.enable_ppt_group_changed(&ctxt).await?;
+            Ok(())
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: platform_profile not supported".to_owned(),
+            ))
+        }
+    }
+
+    #[zbus(property)]
+    async fn platform_profile_linked_epp(&self) -> Result<bool, FdoErr> {
+        Ok(self.config.lock().await.platform_profile_linked_epp)
+    }
+
+    #[zbus(property)]
+    async fn set_platform_profile_linked_epp(&self, linked: bool) -> Result<(), zbus::Error> {
+        self.config.lock().await.platform_profile_linked_epp = linked;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn platform_profile_on_battery(&self) -> Result<PlatformProfile, FdoErr> {
+        Ok(self.config.lock().await.platform_profile_on_battery)
+    }
+
+    #[zbus(property)]
+    async fn set_platform_profile_on_battery(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        policy: PlatformProfile,
+    ) -> Result<(), FdoErr> {
+        self.config.lock().await.platform_profile_on_battery = policy;
+        self.set_platform_profile(ctxt, policy).await?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn change_platform_profile_on_battery(&self) -> Result<bool, FdoErr> {
+        Ok(self.config.lock().await.change_platform_profile_on_battery)
+    }
+
+    #[zbus(property)]
+    async fn set_change_platform_profile_on_battery(&mut self, change: bool) -> Result<(), FdoErr> {
+        self.config.lock().await.change_platform_profile_on_battery = change;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn platform_profile_on_ac(&self) -> Result<PlatformProfile, FdoErr> {
+        Ok(self.config.lock().await.platform_profile_on_ac)
+    }
+
+    #[zbus(property)]
+    async fn set_platform_profile_on_ac(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
+        policy: PlatformProfile,
+    ) -> Result<(), FdoErr> {
+        self.config.lock().await.platform_profile_on_ac = policy;
+        self.set_platform_profile(ctxt, policy).await?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    #[zbus(property)]
+    async fn change_platform_profile_on_ac(&self) -> Result<bool, FdoErr> {
+        Ok(self.config.lock().await.change_platform_profile_on_ac)
+    }
+
+    #[zbus(property)]
+    async fn set_change_platform_profile_on_ac(&mut self, change: bool) -> Result<(), FdoErr> {
+        self.config.lock().await.change_platform_profile_on_ac = change;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// The energy_performance_preference for the quiet throttle/platform
+    /// profile
+    #[zbus(property)]
+    async fn profile_quiet_epp(&self) -> Result<CPUEPP, FdoErr> {
+        Ok(self.config.lock().await.profile_quiet_epp)
+    }
+
+    #[zbus(property)]
+    async fn set_profile_quiet_epp(&mut self, epp: CPUEPP) -> Result<(), FdoErr> {
+        let change_pp = self.config.lock().await.platform_profile_linked_epp;
+        self.config.lock().await.profile_quiet_epp = epp;
+        self.check_and_set_epp(epp, change_pp);
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// The energy_performance_preference for the balanced throttle/platform
+    /// profile
+    #[zbus(property)]
+    async fn profile_balanced_epp(&self) -> Result<CPUEPP, FdoErr> {
+        Ok(self.config.lock().await.profile_balanced_epp)
+    }
+
+    #[zbus(property)]
+    async fn set_profile_balanced_epp(&mut self, epp: CPUEPP) -> Result<(), FdoErr> {
+        let change_pp = self.config.lock().await.platform_profile_linked_epp;
+        self.config.lock().await.profile_balanced_epp = epp;
+        self.check_and_set_epp(epp, change_pp);
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// The energy_performance_preference for the performance throttle/platform
+    /// profile
+    #[zbus(property)]
+    async fn profile_performance_epp(&self) -> Result<CPUEPP, FdoErr> {
+        Ok(self.config.lock().await.profile_performance_epp)
+    }
+
+    #[zbus(property)]
+    async fn set_profile_performance_epp(&mut self, epp: CPUEPP) -> Result<(), FdoErr> {
+        let change_pp = self.config.lock().await.platform_profile_linked_epp;
+        self.config.lock().await.profile_performance_epp = epp;
+        self.check_and_set_epp(epp, change_pp);
+
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    async fn enable_ppt_group(&self) -> Result<bool, FdoErr> {
+        let power_plugged = self
+            .power
+            .get_online()
+            .map_err(|e| {
+                error!("Could not get power status: {e:?}");
+                e
+            })
+            .unwrap_or_default();
+        let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+        Ok(self
+            .config
+            .lock()
+            .await
+            .select_tunings(power_plugged == 1, profile)
+            .enabled)
+    }
+
+    /// Set if the PPT tuning group for the current profile is enabled
+    #[zbus(property)]
+    async fn set_enable_ppt_group(&mut self, enable: bool) -> Result<(), FdoErr> {
+        let power_plugged = self
+            .power
+            .get_online()
+            .map_err(|e| {
+                error!("Could not get power status: {e:?}");
+                e
+            })
+            .unwrap_or_default();
+        let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+
+        if enable {
+            // Clone to reduce blocking
+            let tuning = self
+                .config
+                .lock()
+                .await
+                .select_tunings(power_plugged == 1, profile)
+                .clone();
+
+            for attr in self.attributes.attributes() {
+                let name: FirmwareAttribute = attr.name().into();
+                if name.is_ppt() {
+                    // reset stored value
+                    if let Some(tune) = self
+                        .config
+                        .lock()
+                        .await
+                        .select_tunings(power_plugged == 1, profile)
+                        .group
+                        .get_mut(&name)
+                    {
+                        let value = tuning
+                            .group
+                            .get(&name)
+                            .map(|v| AttrValue::Integer(*v))
+                            .unwrap_or_else(|| attr.default_value().clone());
+                        // restore default
+                        attr.set_current_value(&value)?;
+                        if let AttrValue::Integer(i) = value {
+                            *tune = i
+                        }
+                    }
+                }
+            }
+        } else {
+            // finally, reapply the profile to ensure acpi does the thingy
+            self.platform.set_platform_profile(profile.into())?;
+        }
+
+        self.config
+            .lock()
+            .await
+            .select_tunings(power_plugged == 1, profile)
+            .enabled = enable;
+        self.config.lock().await.write();
+
+        Ok(())
+    }
+}
+
+impl crate::ZbusRun for CtrlPlatform {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, PLATFORM_ZBUS_PATH, server).await;
+    }
+}
+
+impl ReloadAndNotify for CtrlPlatform {
+    type Data = Config;
+
+    /// Called on config file changed externally
+    async fn reload_and_notify(
+        &mut self,
+        signal_context: &SignalEmitter<'static>,
+        data: Self::Data,
+    ) -> Result<(), RogError> {
+        let mut config = self.config.lock().await;
+        if *config != data {
+            info!("asusd.ron updated externally, reloading and updating internal copy");
+
+            let mut base_charge_control_end_threshold = None;
+
+            if self.power.has_charge_control_end_threshold()
+                && data.charge_control_end_threshold != config.charge_control_end_threshold
+            {
+                let limit = data.charge_control_end_threshold;
+                warn!("setting charge_control_end_threshold to {limit}");
+                self.power.set_charge_control_end_threshold(limit)?;
+                self.charge_control_end_threshold_changed(signal_context)
+                    .await?;
+                base_charge_control_end_threshold = (config.base_charge_control_end_threshold > 0)
+                    .then_some(config.base_charge_control_end_threshold)
+                    .or(Some(limit));
+            }
+
+            if self.platform.has_platform_profile()
+                && config.platform_profile_linked_epp != data.platform_profile_linked_epp
+            {
+                let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+
+                let epp = match profile {
+                    PlatformProfile::Balanced => data.profile_balanced_epp,
+                    PlatformProfile::Performance => data.profile_performance_epp,
+                    PlatformProfile::Quiet => data.profile_quiet_epp,
+                    PlatformProfile::LowPower => data.profile_quiet_epp,
+                    PlatformProfile::Custom => data.profile_custom_epp,
+                };
+                warn!("setting epp to {epp:?}");
+                self.check_and_set_epp(epp, true);
+            }
+            // reload_and_notify!(platform_profile, "platform_profile");
+
+            *config = data;
+            config.base_charge_control_end_threshold =
+                base_charge_control_end_threshold.unwrap_or_default();
+        }
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlPlatform {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        info!("Begin Platform settings restore");
+        if self.power.has_charge_control_end_threshold() {
+            // self.restore_charge_limit().await;
+            let limit = self.config.lock().await.charge_control_end_threshold;
+            info!("reloading charge_control_end_threshold to {limit}");
+            self.power.set_charge_control_end_threshold(limit)?;
+        } else {
+            warn!("No charge_control_end_threshold found")
+        }
+
+        if let Ok(power_plugged) = self.power.get_online() {
+            self.config.lock().await.last_power_plugged = power_plugged;
+            if self.platform.has_platform_profile() {
+                let change_epp = self.config.lock().await.platform_profile_linked_epp;
+                self.update_policy_ac_or_bat(power_plugged > 0, change_epp)
+                    .await;
+            }
+            self.run_ac_or_bat_cmd(power_plugged > 0).await;
+        }
+
+        Ok(())
+    }
+}
+
+impl CtrlPlatform {
+    task_watch_item!(charge_control_end_threshold "charge_control_end_threshold" power);
+}
+
+impl CtrlTask for CtrlPlatform {
+    fn zbus_path() -> &'static str {
+        PLATFORM_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalEmitter<'static>) -> Result<(), RogError> {
+        let platform1 = self.clone();
+        let platform2 = self.clone();
+        let platform3 = self.clone();
+        let signal_ctxt_copy = signal_ctxt.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                let platform1 = platform1.clone();
+                async move {
+                    // This block is commented out due to some kind of issue reported. Maybe the
+                    // desktops used were storing a value whcih was then read here.
+                    // Don't store it on suspend, assume that the current config setting is desired
+                    // if sleeping && platform1.power.has_charge_control_end_threshold() {
+                    //     platform1.config.lock().await.charge_control_end_threshold = platform1
+                    //         .power
+                    //         .get_charge_control_end_threshold()
+                    //         .unwrap_or(100);
+                    // } else
+                    if !sleeping && platform1.power.has_charge_control_end_threshold() {
+                        platform1
+                            .power
+                            .set_charge_control_end_threshold(
+                                platform1.config.lock().await.charge_control_end_threshold,
+                            )
+                            .ok();
+                    }
+                    if let Ok(power_plugged) = platform1.power.get_online() {
+                        if platform1.config.lock().await.last_power_plugged != power_plugged {
+                            if !sleeping && platform1.platform.has_platform_profile() {
+                                let change_epp =
+                                    platform1.config.lock().await.platform_profile_linked_epp;
+                                platform1
+                                    .update_policy_ac_or_bat(power_plugged > 0, change_epp)
+                                    .await;
+                            }
+                            if !sleeping {
+                                platform1.run_ac_or_bat_cmd(power_plugged > 0).await;
+                                if let Ok(profile) =
+                                    platform1.platform.get_platform_profile().map(|p| p.into())
+                                {
+                                    let attrs = FirmwareAttributes::new();
+                                    {
+                                        let mut cfg = platform1.config.lock().await;
+                                        set_config_or_default(
+                                            &attrs,
+                                            &mut cfg,
+                                            power_plugged > 0,
+                                            profile,
+                                        )
+                                        .await;
+                                    }
+                                    if let Err(e) = platform1
+                                        .armoury_registry
+                                        .emit_limits(&platform1.connection)
+                                        .await
+                                    {
+                                        error!(
+                                            "Failed to emit armoury updates after power change: \
+                                             {e:?}"
+                                        );
+                                    }
+                                }
+                            }
+                            platform1.config.lock().await.last_power_plugged = power_plugged;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("RogPlatform reloading panel_od");
+                    let lock = platform2.config.lock().await;
+                    if shutting_down
+                        && platform2.power.has_charge_control_end_threshold()
+                        && lock.base_charge_control_end_threshold > 0
+                    {
+                        info!("RogPlatform restoring charge_control_end_threshold");
+                        platform2
+                            .power
+                            .set_charge_control_end_threshold(
+                                lock.base_charge_control_end_threshold,
+                            )
+                            .map_err(|err| {
+                                warn!("CtrlCharge: charge_control_end_threshold {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |power_plugged| {
+                let platform3 = platform3.clone();
+                let signal_ctxt_copy = signal_ctxt.clone();
+                // power change
+                async move {
+                    if platform3.platform.has_platform_profile() {
+                        let change_epp = platform3.config.lock().await.platform_profile_linked_epp;
+                        platform3
+                            .update_policy_ac_or_bat(power_plugged, change_epp)
+                            .await;
+                    }
+                    platform3.run_ac_or_bat_cmd(power_plugged).await;
+                    // In case one-shot charge was used, restore the old charge limit
+                    if platform3.power.has_charge_control_end_threshold() && !power_plugged {
+                        platform3.restore_charge_limit().await;
+                    }
+
+                    if let Ok(profile) = platform3
+                        .platform
+                        .get_platform_profile()
+                        .map(|p| p.into())
+                        .map_err(|e| {
+                            error!("Platform: get_platform_profile error: {e}");
+                        })
+                    {
+                        // TODO: manage this better, shouldn't need to create every time
+                        let attrs = FirmwareAttributes::new();
+                        {
+                            let mut cfg = platform3.config.lock().await;
+                            set_config_or_default(&attrs, &mut cfg, power_plugged, profile).await;
+                        }
+                        if let Err(e) = platform3
+                            .armoury_registry
+                            .emit_limits(&platform3.connection)
+                            .await
+                        {
+                            error!("Failed to emit armoury updates after AC/DC toggle: {e:?}");
+                        }
+                        platform3
+                            .enable_ppt_group_changed(&signal_ctxt_copy)
+                            .await
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        // This spawns a new task for every item.
+        // TODO: find a better way to manage this
+        self.watch_charge_control_end_threshold(signal_ctxt_copy.clone())
+            .await?;
+
+        let watch_platform_profile = self.platform.monitor_platform_profile()?;
+        let ctrl = self.clone();
+
+        // Need a copy here, not ideal. But first use in asus_armoury.rs is
+        // moved to zbus
+        let attrs = FirmwareAttributes::new();
+        tokio::spawn(async move {
+            use futures_lite::StreamExt;
+            let mut buffer = [0; 32];
+            if let Ok(mut stream) = watch_platform_profile.into_event_stream(&mut buffer) {
+                while (stream.next().await).is_some() {
+                    // this blocks
+                    debug!("Platform: watch_platform_profile changed");
+                    if let Ok(profile) = ctrl
+                        .platform
+                        .get_platform_profile()
+                        .map(|p| p.into())
+                        .map_err(|e| {
+                            error!("Platform: get_platform_profile error: {e}");
+                        })
+                    {
+                        let change_epp = ctrl.config.lock().await.platform_profile_linked_epp;
+                        let epp = ctrl.get_config_epp_for_throttle(profile).await;
+                        ctrl.check_and_set_epp(epp, change_epp);
+                        ctrl.platform_profile_changed(&signal_ctxt_copy).await.ok();
+                        ctrl.enable_ppt_group_changed(&signal_ctxt_copy).await.ok();
+                        let power_plugged = ctrl
+                            .power
+                            .get_online()
+                            .map_err(|e| {
+                                error!("Could not get power status: {e:?}");
+                                e
+                            })
+                            .unwrap_or_default();
+                        set_config_or_default(
+                            &attrs,
+                            &mut *ctrl.config.lock().await,
+                            power_plugged == 1,
+                            profile,
+                        )
+                        .await;
+                        if let Err(e) = ctrl.armoury_registry.emit_limits(&ctrl.connection).await {
+                            error!("Failed to emit armoury updates after profile change: {e:?}");
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}

asusd/src/daemon.rs

@@ -0,0 +1,155 @@
+use std::env;
+use std::error::Error;
+use std::sync::Arc;
+
+use ::zbus::Connection;
+use asusd::asus_armoury::{start_attributes_zbus, ArmouryAttributeRegistry};
+use asusd::aura_manager::DeviceManager;
+use asusd::config::Config;
+use asusd::ctrl_backlight::CtrlBacklight;
+use asusd::ctrl_fancurves::CtrlFanCurveZbus;
+use asusd::ctrl_platform::CtrlPlatform;
+use asusd::{print_board_info, start_tasks, CtrlTask, ZbusRun, DBUS_NAME};
+use config_traits::{StdConfig, StdConfigLoad2};
+use log::{error, info};
+use rog_platform::asus_armoury::FirmwareAttributes;
+use rog_platform::platform::RogPlatform;
+use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
+use zbus::fdo::ObjectManager;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Starting asusd daemon...");
+
+    // console_subscriber::init();
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format_timestamp(None)
+        .filter_level(log::LevelFilter::Debug)
+        .init();
+
+    let is_service = match env::var_os("IS_SERVICE") {
+        Some(val) => val == "1",
+        None => true,
+    };
+
+    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{}", asusd::VERSION);
+    info!("    rog-anime v{}", rog_anime::VERSION);
+    info!("    rog-slash v{}", rog_slash::VERSION);
+    info!("     rog-aura v{}", rog_aura::VERSION);
+    info!(" rog-profiles v{}", rog_profiles::VERSION);
+    info!("rog-platform v{}", rog_platform::VERSION);
+
+    start_daemon().await?;
+    Ok(())
+}
+
+/// The actual main loop for the daemon
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
+    // let supported = SupportedFunctions::get_supported();
+    print_board_info();
+    // println!("{:?}", supported.supported_functions());
+
+    // Start zbus server
+    let mut server = Connection::system().await?;
+    if let Err(e) = server.object_server().at("/", ObjectManager).await {
+        error!("Failed to register ObjectManager at root '/': {e:?}");
+    }
+
+    let config = Config::new().load();
+    let cfg_path = config.file_path();
+    let config = Arc::new(Mutex::new(config));
+
+    // supported.add_to_server(&mut connection).await;
+    let platform = RogPlatform::new()?; // TODO: maybe needs async mutex?
+    let power = AsusPower::new()?; // TODO: maybe needs async mutex?
+    let attributes = FirmwareAttributes::new();
+    let armoury_registry = match start_attributes_zbus(
+        &server,
+        platform.clone(),
+        power.clone(),
+        attributes.clone(),
+        config.clone(),
+    )
+    .await
+    {
+        Ok(registry) => {
+            info!("attribute on zbus initialized");
+            registry
+        }
+        Err(e) => {
+            error!("Failed to initialize firmware attributes over zbus: {e:?}");
+            ArmouryAttributeRegistry::default()
+        }
+    };
+
+    match CtrlFanCurveZbus::new() {
+        Ok(ctrl) => {
+            info!("FanCurves: found supported fancurves");
+            let sig_ctx = CtrlFanCurveZbus::signal_context(&server)?;
+            start_tasks(ctrl, &mut server, sig_ctx).await?;
+            info!("FanCurves: initialized");
+        }
+        Err(err) => {
+            error!("FanCurves: {}", err);
+        }
+    }
+
+    match CtrlBacklight::new(config.clone()) {
+        Ok(backlight) => {
+            info!("Backlight: found supported backlight");
+            backlight.start_watch_primary().await?;
+            backlight.add_to_server(&mut server).await;
+            info!("Backlight: initialized");
+        }
+        Err(err) => {
+            error!("Backlight: {}", err);
+        }
+    }
+
+    match CtrlPlatform::new(
+        platform,
+        power,
+        attributes,
+        config.clone(),
+        &cfg_path,
+        CtrlPlatform::signal_context(&server)?,
+        server.clone(),
+        armoury_registry,
+    ) {
+        Ok(ctrl) => {
+            info!("CtrlPlatform: initialized");
+            let sig_ctx = CtrlPlatform::signal_context(&server)?;
+            start_tasks(ctrl, &mut server, sig_ctx).await?;
+            info!("CtrlPlatform: tasks started");
+        }
+        Err(err) => {
+            error!("CtrlPlatform: {}", err);
+        }
+    }
+
+    let _ = DeviceManager::new(server.clone()).await?;
+
+    info!("DeviceManager initialized");
+
+    // Request dbus name after finishing initalizing all functions
+    server.request_name(DBUS_NAME).await?;
+
+    info!("Startup success on dbus name {DBUS_NAME}: begining dbus server loop");
+    loop {
+        // This is just a blocker to idle and ensure the reator reacts
+        server.executor().tick().await;
+    }
+}

asusd/src/error.rs

@@ -1,7 +1,12 @@
-use rog_profiles::error::ProfileError;
 use std::convert::From;
 use std::fmt;
 
+use config_traits::ron;
+use rog_anime::error::AnimeError;
+use rog_platform::error::PlatformError;
+use rog_profiles::error::ProfileError;
+use rog_slash::error::SlashError;
+
 #[derive(Debug)]
 pub enum RogError {
     ParseVendor,
@@ -23,11 +28,21 @@ pub enum RogError {
     Io(std::io::Error),
     Zbus(zbus::Error),
     ChargeLimit(u8),
+    AuraEffectNotSupported,
+    NoAuraKeyboard,
+    NoAuraNode,
+    Anime(AnimeError),
+    Slash(SlashError),
+    Platform(PlatformError),
+    SystemdUnitAction(String),
+    SystemdUnitWaitTimeout(String),
+    Command(String, std::io::Error),
+    ParseRon(ron::Error),
 }
 
 impl fmt::Display for RogError {
     // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
             RogError::ParseLed => write!(f, "Parse LED error"),
@@ -40,14 +55,39 @@ impl fmt::Display for RogError {
             RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
             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::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, "Reload 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::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),
+            RogError::ChargeLimit(value) => {
+                write!(f, "Invalid charging limit, not in range 20-100%: {}", value)
+            }
+            RogError::AuraEffectNotSupported => write!(f, "Aura effect not supported"),
+            RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
+            RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
+            RogError::Anime(deets) => write!(f, "AniMe Matrix error: {}", deets),
+            RogError::Slash(deets) => write!(f, "Slash error: {}", deets),
+            RogError::Platform(deets) => write!(f, "Asus Platform error: {}", deets),
+            RogError::SystemdUnitAction(action) => {
+                write!(f, "systemd unit action {} failed", action)
+            }
+            RogError::SystemdUnitWaitTimeout(state) => {
+                write!(
+                    f,
+                    "Timed out waiting for systemd unit change {} state",
+                    state
+                )
+            }
+            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
+            RogError::ParseRon(error) => write!(f, "Parse config error: {}", error),
         }
     }
 }
@@ -60,6 +100,24 @@ impl From<ProfileError> for RogError {
     }
 }
 
+impl From<AnimeError> for RogError {
+    fn from(err: AnimeError) -> Self {
+        RogError::Anime(err)
+    }
+}
+
+impl From<SlashError> for RogError {
+    fn from(err: SlashError) -> Self {
+        RogError::Slash(err)
+    }
+}
+
+impl From<PlatformError> for RogError {
+    fn from(err: PlatformError) -> Self {
+        RogError::Platform(err)
+    }
+}
+
 impl From<zbus::Error> for RogError {
     fn from(err: zbus::Error) -> Self {
         RogError::Zbus(err)
@@ -72,9 +130,22 @@ impl From<std::io::Error> for RogError {
     }
 }
 
+impl From<ron::Error> for RogError {
+    fn from(err: ron::Error) -> Self {
+        RogError::ParseRon(err)
+    }
+}
+
 impl From<RogError> for zbus::fdo::Error {
     #[inline]
     fn from(err: RogError) -> Self {
         zbus::fdo::Error::Failed(format!("{}", err))
     }
 }
+
+impl From<RogError> for zbus::Error {
+    #[inline]
+    fn from(err: RogError) -> Self {
+        zbus::Error::Failure(format!("{}", err))
+    }
+}

asusd/src/lib.rs

@@ -0,0 +1,320 @@
+#![deny(unused_must_use)]
+/// Configuration loading, saving
+pub mod config;
+pub mod ctrl_backlight;
+/// Control platform profiles + fan-curves if available
+pub mod ctrl_fancurves;
+/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
+pub mod ctrl_platform;
+
+pub mod asus_armoury;
+pub mod aura_anime;
+pub mod aura_laptop;
+pub mod aura_manager;
+pub mod aura_scsi;
+pub mod aura_slash;
+pub mod aura_types;
+pub mod error;
+
+use std::future::Future;
+use std::time::Duration;
+
+use dmi_id::DMIID;
+use futures_lite::stream::StreamExt;
+use log::{debug, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use tokio::time::sleep;
+use zbus::object_server::{Interface, SignalEmitter};
+use zbus::proxy::CacheProperties;
+use zbus::zvariant::ObjectPath;
+use zbus::Connection;
+
+use crate::error::RogError;
+
+const CONFIG_PATH_BASE: &str = "/etc/asusd/";
+pub const ASUS_ZBUS_PATH: &str = "/xyz/ljones";
+
+pub static DBUS_NAME: &str = "xyz.ljones.Asusd";
+pub static DBUS_PATH: &str = "/xyz/ljones/Daemon";
+pub static DBUS_IFACE: &str = "xyz.ljones.Asusd";
+
+/// This macro adds a function which spawns an `inotify` task on the passed in
+/// `Executor`.
+///
+/// The generated function is `watch_<name>()`. Self requires the following
+/// methods to be available:
+/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have
+///   side effects.
+/// - `notify_<name>(SignalEmitter, SomeValue)`
+///
+/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is
+/// expected to update it. The getter should *never* write back to the path or
+/// attribute that is being watched or an infinite loop will occur.
+///
+/// # Example
+///
+/// ```ignore
+/// impl RogPlatform {
+///     task_watch_item!(panel_od platform);
+///     task_watch_item!(gpu_mux_mode platform);
+/// }
+/// ```\
+/// // TODO: this is kind of useless if it can't trigger some action
+#[macro_export]
+macro_rules! task_watch_item {
+    ($name:ident $name_str:literal $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalEmitter<'static>,
+        ) -> Result<(), RogError> {
+            use futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                if let Ok(value) = ctrl.$name() { // get new value from zbus method
+                                    if ctrl.config.lock().await.$name != value {
+                                        log::debug!("{} was changed to {} externally", $name_str, value);
+                                        concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                            ctrl.notif_fn(&signal_ctxt).await.ok();
+                                        });
+                                        let mut lock = ctrl.config.lock().await;
+                                        lock.$name = value;
+                                        lock.write();
+                                    }
+                                }
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+#[macro_export]
+macro_rules! task_watch_item_notify {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalEmitter<'static>,
+        ) -> Result<(), RogError> {
+            use futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                    ctrl.notif_fn(&signal_ctxt).await.ok();
+                                });
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub fn print_board_info() {
+    let dmi = DMIID::new().unwrap_or_default();
+    info!("Product family: {}", dmi.product_family);
+    info!("Board name: {}", dmi.board_name);
+}
+
+pub trait Reloadable {
+    fn reload(&mut self) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ReloadAndNotify {
+    type Data: Send;
+
+    fn reload_and_notify(
+        &mut self,
+        signal_context: &SignalEmitter<'static>,
+        data: Self::Data,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ZbusRun {
+    fn add_to_server(self, server: &mut Connection) -> impl Future<Output = ()> + Send;
+
+    fn add_to_server_helper(
+        iface: impl Interface,
+        path: &str,
+        server: &mut Connection,
+    ) -> impl Future<Output = ()> + Send {
+        async move {
+            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
+pub trait CtrlTask {
+    fn zbus_path() -> &'static str;
+
+    fn signal_context(connection: &Connection) -> Result<SignalEmitter<'static>, zbus::Error> {
+        SignalEmitter::new(connection, Self::zbus_path())
+    }
+
+    /// 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.
+    fn create_tasks(
+        &self,
+        signal: SignalEmitter<'static>,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+
+    // /// Create a timed repeating task
+    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send +
+    // 'static) {     use std::time::Duration;
+    //     use tokio::time;
+    //     let mut timer = time::interval(Duration::from_millis(millis));
+    //     tokio::spawn(async move {
+    //         timer.tick().await;
+    //         task();
+    //     });
+    // }
+
+    /// Free helper method to create tasks to run on: sleep, wake, shutdown,
+    /// boot
+    ///
+    /// The closures can potentially block, so execution time should be the
+    /// minimal possible such as save a variable.
+    fn create_sys_event_tasks<Fut1, Fut2, Fut3, Fut4, F1, F2, F3, F4>(
+        &self,
+        mut on_prepare_for_sleep: F1,
+        mut on_prepare_for_shutdown: F2,
+        mut on_lid_change: F3,
+        mut on_external_power_change: F4,
+    ) -> impl Future<Output = ()> + Send
+    where
+        F1: FnMut(bool) -> Fut1 + Send + 'static,
+        F2: FnMut(bool) -> Fut2 + Send + 'static,
+        F3: FnMut(bool) -> Fut3 + Send + 'static,
+        F4: FnMut(bool) -> Fut4 + Send + 'static,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
+        async {
+            let connection = Connection::system()
+                .await
+                .expect("Controller could not create dbus connection");
+
+            let manager = ManagerProxy::builder(&connection)
+                .cache_properties(CacheProperties::No)
+                .build()
+                .await
+                .expect("Controller could not create ManagerProxy");
+
+            let manager1 = manager.clone();
+            tokio::spawn(async move {
+                if let Ok(mut notif) = manager1.receive_prepare_for_shutdown().await {
+                    while let Some(event) = notif.next().await {
+                        // blocks thread :|
+                        if let Ok(args) = event.args() {
+                            debug!("Doing on_prepare_for_shutdown({})", args.start);
+                            on_prepare_for_shutdown(args.start).await;
+                        }
+                    }
+                }
+            });
+
+            let manager2 = manager.clone();
+            tokio::spawn(async move {
+                if let Ok(mut notif) = manager2.receive_prepare_for_sleep().await {
+                    while let Some(event) = notif.next().await {
+                        // blocks thread :|
+                        if let Ok(args) = event.args() {
+                            debug!("Doing on_prepare_for_sleep({})", args.start);
+                            on_prepare_for_sleep(args.start).await;
+                        }
+                    }
+                }
+            });
+
+            let manager3 = manager.clone();
+            tokio::spawn(async move {
+                let mut last_power = manager3.on_external_power().await.unwrap_or_default();
+
+                loop {
+                    if let Ok(next) = manager3.on_external_power().await {
+                        if next != last_power {
+                            last_power = next;
+                            on_external_power_change(next).await;
+                        }
+                    }
+                    sleep(Duration::from_secs(2)).await;
+                }
+            });
+
+            tokio::spawn(async move {
+                let mut last_lid = manager.lid_closed().await.unwrap_or_default();
+                // need to loop on these as they don't emit signals
+                loop {
+                    if let Ok(next) = manager.lid_closed().await {
+                        if next != last_lid {
+                            last_lid = next;
+                            on_lid_change(next).await;
+                        }
+                    }
+                    sleep(Duration::from_secs(2)).await;
+                }
+            });
+        }
+    }
+}
+
+pub trait GetSupported {
+    type A;
+
+    fn get_supported() -> Self::A;
+}
+
+pub async fn start_tasks<T>(
+    mut zbus: T,
+    connection: &mut Connection,
+    signal_ctx: SignalEmitter<'static>,
+) -> Result<(), RogError>
+where
+    T: ZbusRun + Reloadable + CtrlTask + Clone,
+{
+    let zbus_clone = zbus.clone();
+
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    zbus.add_to_server(connection).await;
+
+    zbus_clone.create_tasks(signal_ctx).await.ok();
+    Ok(())
+}

config-traits/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "config-traits"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[dependencies]
+serde.workspace = true
+ron.workspace = true
+
+log.workspace = true

config-traits/README.md

@@ -0,0 +1,10 @@
+# config-traits
+
+`config_traits` is a crate that broke out from the requirement to manage various
+different config files, including parsing from different formats and updating
+them from previous versions where fields or names are changed in some way.
+
+The end canonical file format is `.ron` as this supports rust types well, and includes
+the ability to add commenting, and is less verbose than `json`. Currently the crate will
+also try to parse from `json` and `toml` if the `ron` parsing fails, then update to `ron`
+format.

config-traits/src/lib.rs

@@ -0,0 +1,328 @@
+//! `config_traits` is a crate that broke out from the requirement to manage
+//! various different config files, including parsing from different formats and
+//! updating them from previous versions where fields or names are changed in
+//! some way.
+//!
+//! The end canonical file format is `.ron` as this supports rust types well
+
+use std::fs::{self, create_dir, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use log::{error, warn};
+pub use ron;
+use ron::ser::PrettyConfig;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+/// Config file helper traits. Only `new()` and `file_name()` are required to be
+/// implemented, the rest are intended to be free methods.
+pub trait StdConfig
+where
+    Self: Serialize + DeserializeOwned,
+{
+    /// Taking over the standard `new()` to ensure things can be generic
+    fn new() -> Self;
+
+    /// Return the config files names, such as `wibble.cfg`
+    fn file_name(&self) -> String;
+
+    /// Return the full path to the directory the config file resides in
+    fn config_dir() -> PathBuf;
+
+    /// Return the full path to the config file
+    fn file_path(&self) -> PathBuf {
+        let mut config = Self::config_dir();
+        if !config.exists() {
+            create_dir(config.as_path())
+                .unwrap_or_else(|e| panic!("Could not create {:?} {e}", Self::config_dir()));
+        }
+        config.push(self.file_name());
+        let mut do_rename = !config.exists();
+        let mut cfg_old = config.clone();
+        // Migrating all configs to .ron format, so we do need to check for older ones
+        if do_rename {
+            warn!("Config {cfg_old:?} does not exist, looking for .cfg next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.cfg", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+            do_rename = false;
+        }
+        if do_rename && !cfg_old.exists() {
+            warn!("Config {cfg_old:?} does not exist, looking for .conf next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.conf", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+        }
+        config
+    }
+
+    /// Directly open the config file for read and write. If the config file
+    /// does not exist it is created, including the directories the file
+    /// resides in.
+    fn file_open(&self) -> File {
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(self.file_path())
+            .unwrap_or_else(|e| panic!("Could not open {:?} {e}", self.file_path()))
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read(&mut self) {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                *self = data;
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read_new(&self) -> Option<Self> {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                return Some(data);
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+        None
+    }
+
+    /// Write the config file data to pretty ron format
+    fn write(&self) {
+        let mut file = match File::create(self.file_path()) {
+            Ok(data) => data,
+            Err(e) => {
+                error!(
+                    "Couldn't overwrite config {:?}, error: {e}",
+                    self.file_path()
+                );
+                return;
+            }
+        };
+        let ron = match ron::ser::to_string_pretty(&self, PrettyConfig::new().depth_limit(4)) {
+            Ok(data) => data,
+            Err(e) => {
+                error!("Parse {:?} to RON failed, error: {e}", self.file_path());
+                return;
+            }
+        };
+        file.write_all(ron.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+
+    /// Renames the existing file to `<file>-old`
+    fn rename_file_old(&self) {
+        warn!("Renaming {} to {}-old", self.file_name(), self.file_name());
+        let mut cfg_old = self.file_path().to_string_lossy().to_string();
+        cfg_old.push_str("-old");
+        std::fs::rename(self.file_path(), cfg_old).unwrap_or_else(|err| {
+            error!(
+                "Could not rename. Please remove {} then restart service: Error {}",
+                self.file_name(),
+                err
+            );
+        });
+    }
+}
+
+#[macro_export]
+macro_rules! std_config_load {
+    ($trait_name:ident: $($generic:ident),*) => {
+        /// Base trait for loading/parsing. This is intended to be used to help update
+        /// configs to new versions
+        ///
+        /// # Example
+        /// ```rust
+        /// use std::path::PathBuf;
+        /// use serde::{Deserialize, Serialize};
+        /// use config_traits::{StdConfig, StdConfigLoad2};
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOld {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOlder {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfig {}
+        ///
+        /// impl From<FanCurveConfigOld> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOld) -> Self { Self {} }
+        /// }
+        ///
+        /// impl From<FanCurveConfigOlder> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOlder) -> Self { Self {} }
+        /// }
+        ///
+        /// impl StdConfig for FanCurveConfig {
+        ///     fn new() -> Self { Self {} }
+        ///
+        ///     fn file_name(&self) -> std::string::String { "test_name.conf".to_owned() }
+        ///
+        ///     fn config_dir() -> PathBuf { PathBuf::from("/tmp") }
+        /// }
+        ///
+        /// impl StdConfigLoad2<FanCurveConfigOld, FanCurveConfigOlder> for FanCurveConfig {}
+        /// ```
+        ///
+        /// If all of the generics fails to parse, then the old config is renamed and a
+        /// new one created
+        pub trait $trait_name<$($generic),*>
+        where
+            Self: $crate::StdConfig + DeserializeOwned + Serialize,
+            $($generic: DeserializeOwned + Into<Self>),*
+        {
+            fn load(mut self) -> Self {
+                let mut file = self.file_open();
+                let mut buf = String::new();
+                if let Ok(read_len) = file.read_to_string(&mut buf) {
+                    if read_len != 0 {
+                        if let Ok(data) = ron::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed RON for {:?}", std::any::type_name::<Self>());
+                        }  $(else if let Ok(data) = ron::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed RON for {:?}", std::any::type_name::<$generic>());
+                        })* else {
+                            self.rename_file_old();
+                            self = Self::new();
+                        }
+                    } else {
+                        error!("Config file {} zero read length", self.file_name());
+                    }
+                }
+                self.write();
+                self
+            }
+        }
+    };
+}
+
+std_config_load!(StdConfigLoad:);
+std_config_load!(StdConfigLoad1: T1);
+std_config_load!(StdConfigLoad2: T1, T2);
+std_config_load!(StdConfigLoad3: T1, T2, T3);
+std_config_load!(StdConfigLoad4: T1, T2, T3, T4);
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    #[test]
+    fn check_macro_from_1() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        let _ = Test {};
+
+        impl crate::StdConfigLoad1<Old1> for Test {}
+    }
+
+    #[test]
+    fn check_macro_from_3() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old2 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old3 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old2> for Test {
+            fn from(_: Old2) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old3> for Test {
+            fn from(_: Old3) -> Self {
+                Self {}
+            }
+        }
+
+        let _ = Test {};
+
+        impl crate::StdConfigLoad3<Old1, Old2, Old3> for Test {}
+    }
+}

daemon-user/Cargo.toml

@@ -1,30 +0,0 @@
-[package]
-name = "daemon-user"
-version = "1.2.0"
-authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
-description = "Usermode daemon for user settings, anime, per-key lighting"
-
-[lib]
-name = "rog_user"
-path = "src/lib.rs"
-
-[[bin]]
-name = "asusd-user"
-path = "src/daemon.rs"
-
-[dependencies]
-# serialisation
-serde = "^1.0"
-serde_json = "^1.0"
-serde_derive = "^1.0"
-
-rog_anime = { path = "../rog-anime" }
-rog_dbus = { path = "../rog-dbus" }
-rog_supported = { path = "../rog-supported" }
-
-dirs = "3.0.1"
-
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"

daemon-user/src/daemon.rs

@@ -1,67 +0,0 @@
-use rog_dbus::RogDbusClient;
-use rog_user::{
-    ctrl_anime::{CtrlAnime, CtrlAnimeInner},
-    user_config::*,
-    DBUS_NAME,
-};
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread;
-use zbus::{fdo, 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-supported v{}", rog_supported::VERSION);
-
-    let (client, _) = RogDbusClient::new()?;
-    let supported = client.proxies().supported().get_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);
-
-    // 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()?;
-        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().ok();
-                }
-            })?;
-    }
-
-    if supported.keyboard_led.per_key_led_mode {}
-
-    loop {
-        if let Err(err) = server.try_handle_next() {
-            println!("{}", err);
-        }
-    }
-}

daemon-user/src/user_config.rs

@@ -1,225 +0,0 @@
-use std::{
-    fs::{create_dir, OpenOptions},
-    io::{Read, Write},
-    time::Duration,
-};
-
-use rog_anime::{ActionLoader, AnimTime, Fade, Sequences, Vec2};
-use serde_derive::{Deserialize, Serialize};
-
-use crate::error::Error;
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UserAnimeConfig {
-    pub name: String,
-    pub anime: Vec<ActionLoader>,
-}
-
-impl UserAnimeConfig {
-    pub fn create_anime(&self) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new();
-
-        for (idx, action) in self.anime.iter().enumerate() {
-            seq.insert(idx, action)?;
-        }
-
-        Ok(seq)
-    }
-
-    pub fn write(&self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-        let name = self.name.clone();
-        path.push(name + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-
-    pub fn load_config(name: String) -> Result<UserAnimeConfig, Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push(name.clone() + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let default = UserAnimeConfig {
-                    name,
-                    ..Default::default()
-                };
-                let json = serde_json::to_string_pretty(&default).unwrap();
-                file.write_all(json.as_bytes())?;
-                return Ok(default);
-            } else if let Ok(data) = serde_json::from_str::<UserAnimeConfig>(&buf) {
-                return Ok(data);
-            }
-        }
-        Err(Error::ConfigLoadFail)
-    }
-}
-
-impl Default for UserAnimeConfig {
-    fn default() -> Self {
-        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,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(6),
-                        None,
-                        Duration::from_secs(3),
-                    )),
-                },
-                ActionLoader::ImageAnimation {
-                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                    scale: 0.9,
-                    angle: 0.65,
-                    translation: Vec2::default(),
-                    brightness: 0.5,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        Some(Duration::from_secs(2)),
-                        Duration::from_secs(2),
-                    )),
-                },
-                ActionLoader::Image {
-                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
-                    scale: 1.0,
-                    angle: 0.0,
-                    translation: Vec2::default(),
-                    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)),
-                ActionLoader::ImageAnimation {
-                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
-                    scale: 0.9,
-                    angle: 0.0,
-                    translation: Vec2::new(3.0, 2.0),
-                    brightness: 0.5,
-                    time: AnimTime::Count(2),
-                },
-            ],
-        }
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct UserConfig {
-    /// Name of active anime config file in the user config directory
-    pub active_anime: String,
-}
-
-impl UserConfig {
-    pub fn new() -> Self {
-        Self {
-            active_anime: "anime-default".to_string(),
-        }
-    }
-
-    pub fn load_config(&mut self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let json = serde_json::to_string_pretty(&self).unwrap();
-                file.write_all(json.as_bytes())?;
-            } else if let Ok(data) = serde_json::from_str::<UserConfig>(&buf) {
-                self.active_anime = data.active_anime;
-                return Ok(());
-            }
-        }
-        Ok(())
-    }
-
-    pub fn write(&self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-}

daemon/Cargo.toml

@@ -1,45 +0,0 @@
-[package]
-name = "daemon"
-version = "4.0.5"
-license = "MPL-2.0"
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2018"
-
-[lib]
-name = "daemon"
-path = "src/lib.rs"
-
-[[bin]]
-name = "asusd"
-path = "src/daemon.rs"
-
-[dependencies]
-rog_anime = { path = "../rog-anime" }
-rog_aura = { path = "../rog-aura" }
-rog_supported = { path = "../rog-supported" }
-rog_profiles = { path = "../rog-profiles" }
-rog_dbus = { path = "../rog-dbus" }
-rusb = "^0.8"
-udev = "^0.6"
-
-# cli and logging
-log = "^0.4"
-env_logger = "^0.8"
-
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = { version = "^2.6" }
-logind-zbus = "^0.7.1"
-
-# serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "^0.5.8"
-
-# Device control
-sysfs-class = "^0.1.2" # used for backlight control and baord ID

daemon/src/config.rs

@@ -1,79 +0,0 @@
-use log::{error, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-
-pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-
-#[derive(Deserialize, Serialize)]
-pub struct Config {
-    /// Save charge limit for restoring on boot
-    pub bat_charge_limit: u8,
-}
-
-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
-        let mut buf = String::new();
-        let config;
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                config = Self::new();
-            } else if let Ok(data) = serde_json::from_str(&buf) {
-                config = data;
-            } else {
-                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.write();
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", 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 {}", CONFIG_PATH);
-            } else {
-                *self = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_anime/config.rs

@@ -1,255 +0,0 @@
-use crate::VERSION;
-use log::{error, info, warn};
-use rog_anime::Fade;
-use rog_anime::{error::AnimeError, ActionData, ActionLoader, AnimTime, Vec2};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-use std::time::Duration;
-
-pub static ANIME_CONFIG_PATH: &str = "/etc/asusd/anime.conf";
-pub static ANIME_CACHE_PATH: &str = "/etc/asusd/anime-cache.conf";
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV341 {
-    pub system: Option<ActionLoader>,
-    pub boot: Option<ActionLoader>,
-    pub suspend: Option<ActionLoader>,
-    pub shutdown: Option<ActionLoader>,
-}
-
-impl AnimeConfigV341 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: if let Some(ani) = self.system {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            boot: if let Some(ani) = self.boot {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            wake: if let Some(ani) = self.suspend {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            shutdown: if let Some(ani) = self.shutdown {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV352 {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-}
-
-impl AnimeConfigV352 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: self.system,
-            boot: self.boot,
-            wake: self.wake,
-            shutdown: self.shutdown,
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Default)]
-pub struct AnimeConfigCached {
-    pub system: Vec<ActionData>,
-    pub boot: Vec<ActionData>,
-    pub wake: Vec<ActionData>,
-    pub shutdown: Vec<ActionData>,
-}
-
-impl AnimeConfigCached {
-    pub fn init_from_config(&mut self, config: &AnimeConfig) -> Result<(), AnimeError> {
-        let mut sys = Vec::with_capacity(config.system.len());
-        for ani in config.system.iter() {
-            sys.push(ActionData::from_anime_action(ani)?);
-        }
-        self.system = sys;
-
-        let mut boot = Vec::with_capacity(config.boot.len());
-        for ani in config.boot.iter() {
-            boot.push(ActionData::from_anime_action(ani)?);
-        }
-        self.boot = boot;
-
-        let mut wake = Vec::with_capacity(config.wake.len());
-        for ani in config.wake.iter() {
-            wake.push(ActionData::from_anime_action(ani)?);
-        }
-        self.wake = wake;
-
-        let mut shutdown = Vec::with_capacity(config.shutdown.len());
-        for ani in config.shutdown.iter() {
-            shutdown.push(ActionData::from_anime_action(ani)?);
-        }
-        self.shutdown = shutdown;
-        Ok(())
-    }
-}
-
-/// Config for base system actions for the anime display
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfig {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-    pub awake_enabled: bool,
-    pub boot_anim_enabled: bool,
-}
-
-impl Default for AnimeConfig {
-    fn default() -> Self {
-        AnimeConfig {
-            system: Vec::new(),
-            boot: Vec::new(),
-            wake: Vec::new(),
-            shutdown: Vec::new(),
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-impl AnimeConfig {
-    /// `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(&ANIME_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    ANIME_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                return AnimeConfig::create_default(&mut file);
-            } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
-                    return data;
-                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV341>(&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::<AnimeConfigV352>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                }
-                warn!(
-                    "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)
-    }
-
-    fn create_default(file: &mut File) -> Self {
-        // create a default config here
-        let config = AnimeConfig {
-            system: vec![],
-            boot: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            wake: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            shutdown: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
-                scale: 0.9,
-                angle: 0.0,
-                translation: Vec2::new(3.0, 2.0),
-                brightness: 1.0,
-                time: AnimTime::Infinite,
-            }],
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        };
-        // 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 {}", ANIME_CONFIG_PATH));
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&ANIME_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", ANIME_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 {}", ANIME_CONFIG_PATH);
-            } else {
-                let x: AnimeConfig = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", ANIME_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(ANIME_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_anime/mod.rs

@@ -1,402 +0,0 @@
-pub mod config;
-pub mod zbus;
-
-use ::zbus::Connection;
-use log::{error, info, warn};
-use logind_zbus::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 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 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) => {
-                                if let Err(err) = rog_anime::run_animation(
-                                    frames,
-                                    thread_exit.clone(),
-                                    &|frame| {
-                                        inner
-                                            .try_lock()
-                                            .map(|lock| lock.write_data_buffer(frame))
-                                            .map_err(|err| {
-                                                warn!("rog_anime::run_animation: {}", err);
-                                                AnimeError::NoFrames
-                                            })
-                                    },
-                                ) {
-                                    warn!("rog_anime::run_animation: {}", err);
-                                    break 'main;
-                                };
-
-                                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]) {
-        // 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<'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().expect("CtrlAnimeTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlAnimeTask could not create ManagerProxy");
-
-        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(())
-    }
-}

daemon/src/ctrl_anime/zbus.rs

@@ -1,140 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use log::warn;
-use rog_anime::{
-    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
-    AnimeDataBuffer, AnimePowerStates,
-};
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-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
-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_aura/config.rs

@@ -1,276 +0,0 @@
-use crate::laptops::LaptopLedData;
-use log::{error, info, warn};
-use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
-use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::fs::{File, OpenOptions};
-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,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl AuraConfigV352 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: 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 AuraConfig {
-    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,
-}
-
-impl Default for AuraConfig {
-    fn default() -> Self {
-        AuraConfig {
-            brightness: LedBrightness::Med,
-            current_mode: AuraModeNum::Static,
-            builtins: BTreeMap::new(),
-            multizone: None,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
-        }
-    }
-}
-
-impl AuraConfig {
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load(supported_led_modes: &LaptopLedData) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&AURA_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    AURA_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        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);
-            } 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;
-                }
-                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)
-    }
-
-    fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
-        // create a default config here
-        let mut config = AuraConfig::default();
-
-        for n in &support_data.standard {
-            config
-                .builtins
-                .insert(*n, AuraEffect::default_with_mode(*n));
-        }
-
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", AURA_CONFIG_PATH));
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&AURA_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", AURA_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 {}", AURA_CONFIG_PATH);
-            } else {
-                let x: AuraConfig = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(AURA_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-
-    /// 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 => {
-                self.builtins.insert(*effect.mode(), effect);
-            }
-            _ => {
-                if let Some(multi) = self.multizone.as_mut() {
-                    multi.set(effect)
-                }
-            }
-        }
-    }
-
-    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect; 4]> {
-        if let Some(multi) = &self.multizone {
-            if aura_type == AuraModeNum::Static {
-                return Some(multi.static_());
-            } else if aura_type == AuraModeNum::Breathe {
-                return Some(multi.breathe());
-            }
-        }
-        None
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AuraMultiZone {
-    static_: [AuraEffect; 4],
-    breathe: [AuraEffect; 4],
-}
-
-impl AuraMultiZone {
-    pub fn set(&mut self, effect: AuraEffect) {
-        if effect.mode == AuraModeNum::Static {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.static_[0] = effect,
-                AuraZone::Two => self.static_[1] = effect,
-                AuraZone::Three => self.static_[2] = effect,
-                AuraZone::Four => self.static_[3] = effect,
-            }
-        } else if effect.mode == AuraModeNum::Breathe {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.breathe[0] = effect,
-                AuraZone::Two => self.breathe[1] = effect,
-                AuraZone::Three => self.breathe[2] = effect,
-                AuraZone::Four => self.breathe[3] = effect,
-            }
-        }
-    }
-
-    pub fn static_(&self) -> &[AuraEffect; 4] {
-        &self.static_
-    }
-
-    pub fn breathe(&self) -> &[AuraEffect; 4] {
-        &self.breathe
-    }
-}
-
-impl Default for AuraMultiZone {
-    fn default() -> Self {
-        Self {
-            static_: [
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-            breathe: [
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-        }
-    }
-}

daemon/src/ctrl_aura/controller.rs

@@ -1,419 +0,0 @@
-// Only these two packets must be 17 bytes
-static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
-
-use crate::{
-    error::RogError,
-    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-    CtrlTask,
-};
-use log::{info, warn};
-use logind_zbus::ManagerProxy;
-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,
-    },
-    AuraEffect, LedBrightness, LED_MSG_LEN,
-};
-use rog_supported::LedSupportedFunctions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::{fs::OpenOptions, thread::spawn};
-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;
-
-        LedSupportedFunctions {
-            brightness_set: CtrlKbdLed::get_kbd_bright_path().is_some(),
-            stock_led_modes,
-            multizone_led_mode,
-            per_key_led_mode,
-        }
-    }
-}
-
-pub struct CtrlKbdLed {
-    pub led_node: Option<String>,
-    pub bright_node: String,
-    pub supported_modes: LaptopLedData,
-    pub flip_effect_write: bool,
-    pub config: AuraConfig,
-}
-
-pub struct CtrlKbdLedTask<'a> {
-    inner: Arc<Mutex<CtrlKbdLed>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
-}
-
-impl<'a> CtrlKbdLedTask<'a> {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        let connection =
-            Connection::new_system().expect("CtrlKbdLedTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlKbdLedTask could not create ManagerProxy");
-
-        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,
-        }
-    }
-
-    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&lock.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&lock.bright_node).into(), err)
-                }
-                _ => RogError::Path((&lock.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if lock.config.brightness != num.into() {
-                lock.config.read();
-                lock.config.brightness = num.into();
-                lock.config.write();
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLed)
-    }
-}
-
-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);
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedReloader(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl crate::Reloadable for CtrlKbdLedReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            let current = ctrl.config.current_mode;
-            if let Some(mode) = ctrl.config.builtins.get(&current).cloned() {
-                ctrl.do_command(mode).ok();
-            }
-
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl CtrlKbdLedZbus {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        Self(inner)
-    }
-}
-
-impl CtrlKbdLed {
-    #[inline]
-    pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
-        // TODO: return error if *all* nodes are None
-        let mut led_node = None;
-        for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            match Self::find_led_node(prod) {
-                Ok(node) => {
-                    led_node = Some(node);
-                    break;
-                }
-                Err(err) => warn!("led_node: {}", err),
-            }
-        }
-
-        let bright_node = Self::get_kbd_bright_path();
-
-        if led_node.is_none() && bright_node.is_none() {
-            return Err(RogError::MissingFunction(
-                "All keyboard features missing, you may require a v5.11 series kernel or newer"
-                    .into(),
-            ));
-        }
-
-        if bright_node.is_none() {
-            return Err(RogError::MissingFunction(
-                "No brightness control, you may require a v5.11 series kernel or newer".into(),
-            ));
-        }
-
-        let ctrl = CtrlKbdLed {
-            led_node,
-            bright_node: bright_node.unwrap(), // If was none then we already returned above
-            supported_modes,
-            flip_effect_write: false,
-            config,
-        };
-        Ok(ctrl)
-    }
-
-    fn get_kbd_bright_path() -> Option<String> {
-        if Path::new(KBD_BRIGHT_PATH).exists() {
-            return Some(KBD_BRIGHT_PATH.to_string());
-        }
-        None
-    }
-
-    pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                }
-                _ => RogError::Path((&self.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(buf[0])
-    }
-
-    pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
-        let path = Path::new(&self.bright_node);
-        let mut file =
-            OpenOptions::new()
-                .write(true)
-                .open(&path)
-                .map_err(|err| match err.kind() {
-                    std::io::ErrorKind::NotFound => {
-                        RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                    }
-                    _ => RogError::Path((&self.bright_node).into(), err),
-                })?;
-        file.write_all(&[brightness.as_char_code()])
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(())
-    }
-
-    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 {
-            bright -= 1;
-        }
-        self.config.brightness = <LedBrightness>::from(bright);
-        self.config.write();
-        self.set_brightness(self.config.brightness)
-    }
-
-    /// 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
-        } else {
-            LED_AWAKE_ON_SLEEP_ON
-        };
-        self.write_bytes(&bytes)?;
-        self.write_bytes(&LED_SET)?;
-        // Changes won't persist unless apply is set
-        self.write_bytes(&LED_APPLY)?;
-        Ok(())
-    }
-
-    fn find_led_node(id_product: &str) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("hidraw").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(parent) = device
-                .parent_with_subsystem_devtype("usb", "usb_device")
-                .map_err(|err| {
-                    warn!("{}", err);
-                    RogError::Udev("parent_with_subsystem_devtype failed".into(), err)
-                })?
-            {
-                if parent
-                    .attribute_value("idProduct")
-                    .ok_or_else(|| RogError::NotFound("LED idProduct".into()))?
-                    == id_product
-                {
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for LED control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        Err(RogError::MissingFunction(
-            "ASUS LED device node not found".into(),
-        ))
-    }
-
-    pub(crate) fn do_command(&mut self, mode: AuraEffect) -> Result<(), RogError> {
-        self.set_and_save(mode)
-    }
-
-    /// Should only be used if the bytes you are writing are verified correct
-    #[inline]
-    fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
-        if let Some(led_node) = &self.led_node {
-            if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
-                // println!("write: {:02x?}", &message);
-                return file
-                    .write_all(message)
-                    .map_err(|err| RogError::Write("write_bytes".into(), err));
-            }
-        }
-        Err(RogError::NotSupported)
-    }
-
-    /// Write an effect block
-    #[inline]
-    fn _write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), RogError> {
-        if self.flip_effect_write {
-            for row in effect.iter().rev() {
-                self.write_bytes(row)?;
-            }
-        } else {
-            for row in effect.iter() {
-                self.write_bytes(row)?;
-            }
-        }
-        self.flip_effect_write = !self.flip_effect_write;
-        Ok(())
-    }
-
-    /// Used to set a builtin mode and save the settings for it
-    ///
-    /// This needs to be universal so that settings applied by dbus stick
-    #[inline]
-    fn set_and_save(&mut self, mode: AuraEffect) -> Result<(), RogError> {
-        self.config.read();
-        self.write_mode(&mode)?;
-        self.config.current_mode = *mode.mode();
-        self.config.set_builtin(mode);
-        self.config.write();
-        Ok(())
-    }
-
-    #[inline]
-    pub(super) fn toggle_mode(&mut self, reverse: bool) -> Result<(), RogError> {
-        let current = self.config.current_mode;
-        if let Some(idx) = self
-            .supported_modes
-            .standard
-            .iter()
-            .position(|v| *v == current)
-        {
-            let mut idx = idx;
-            // goes past end of array
-            if reverse {
-                if idx == 0 {
-                    idx = self.supported_modes.standard.len() - 1;
-                } else {
-                    idx -= 1;
-                }
-            } else {
-                idx += 1;
-                if idx == self.supported_modes.standard.len() {
-                    idx = 0;
-                }
-            }
-            let next = self.supported_modes.standard[idx];
-
-            self.config.read();
-            if let Some(data) = self.config.builtins.get(&next) {
-                self.write_mode(data)?;
-                self.config.current_mode = next;
-            }
-            self.config.write();
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn write_mode(&self, mode: &AuraEffect) -> Result<(), RogError> {
-        if !self.supported_modes.standard.contains(mode.mode()) {
-            return Err(RogError::NotSupported);
-        }
-        let bytes: [u8; LED_MSG_LEN] = mode.into();
-        self.write_bytes(&bytes)?;
-        self.write_bytes(&LED_SET)?;
-        // Changes won't persist unless apply is set
-        self.write_bytes(&LED_APPLY)?;
-        Ok(())
-    }
-}

daemon/src/ctrl_aura/mod.rs

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

daemon/src/ctrl_aura/zbus.rs

@@ -1,179 +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));
-            }
-        }
-    }
-
-    fn next_led_brightness(&self) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.next_brightness()
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-
-    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)]
-    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_charge.rs

@@ -1,132 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
-use rog_supported::ChargeSupportedFunctions;
-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;
-
-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;
-
-    fn get_supported() -> Self::A {
-        ChargeSupportedFunctions {
-            charge_level_set: CtrlCharge::get_battery_path().is_ok(),
-        }
-    }
-}
-
-pub struct CtrlCharge {
-    config: Arc<Mutex<Config>>,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlCharge {
-    pub fn set_limit(&mut self, limit: u8) -> Result<(), RogError> {
-        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)
-                .map_err(|err| {
-                    warn!("CtrlCharge: set_limit {}", err);
-                    err
-                })
-                .ok();
-        }
-        Ok(())
-    }
-
-    pub fn limit(&self) -> i8 {
-        if let Ok(config) = self.config.try_lock() {
-            return config.bat_charge_limit as i8;
-        }
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
-}
-
-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();
-    }
-}
-
-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)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlCharge {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        CtrlCharge::get_battery_path()?;
-        Ok(CtrlCharge { config })
-    }
-
-    fn get_battery_path() -> Result<&'static str, RogError> {
-        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"
-                    .into(),
-            ))
-        }
-    }
-
-    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit));
-        }
-
-        let path = Self::get_battery_path()?;
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-        file.write_all(limit.to_string().as_bytes())
-            .map_err(|err| RogError::Write(path.into(), err))?;
-        info!("Battery charge limit: {}", limit);
-
-        config.read();
-        config.bat_charge_limit = limit;
-        config.write();
-
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/config.rs

@@ -1,101 +0,0 @@
-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,151 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use crate::error::RogError;
-use crate::{CtrlTask, GetSupported};
-use log::{info, warn};
-use rog_profiles::error::ProfileError;
-use rog_profiles::{FanCurveProfiles, Profile};
-use rog_supported::PlatformProfileFunctions;
-
-use super::config::ProfileConfig;
-
-pub struct CtrlPlatformProfile {
-    pub config: ProfileConfig,
-}
-
-impl GetSupported for CtrlPlatformProfile {
-    type A = PlatformProfileFunctions;
-
-    fn get_supported() -> Self::A {
-        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 with the following patch applied:
-https://lkml.org/lkml/2021/8/18/1022
-"#
-            );
-        }
-
-        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/8/20/232
-Please note that as of 24/08/2021 this is not final.
-"#
-            );
-        }
-
-        PlatformProfileFunctions {
-            platform_profile: Profile::is_platform_profile_supported(),
-            fan_curves: fan_curve_supported,
-        }
-    }
-}
-
-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 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 CtrlPlatformProfile {
-    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
-        if Profile::is_platform_profile_supported() {
-            info!("Device has profile control available");
-
-            if FanCurveProfiles::get_device().is_ok() {
-                info!("Device has fan curves available");
-            }
-
-            return Ok(CtrlPlatformProfile { config });
-        }
-
-        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_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 struct CtrlProfileTask {
-    ctrl: Arc<Mutex<CtrlPlatformProfile>>,
-}
-
-impl CtrlProfileTask {
-    pub fn new(ctrl: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { ctrl }
-    }
-}
-
-impl CtrlTask for CtrlProfileTask {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(ref mut lock) = self.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()?;
-                lock.save_config();
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/mod.rs

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

daemon/src/ctrl_profiles/zbus.rs

@@ -1,189 +0,0 @@
-use log::warn;
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::fan_curve_set::FanCurveSet;
-use rog_profiles::Profile;
-
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::{dbus_interface, fdo::Error};
-use zvariant::ObjectPath;
-
-use super::controller::CtrlPlatformProfile;
-
-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 ProfileZbus {
-    pub fn new(inner: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { inner }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl ProfileZbus {
-    /// Fetch profile names
-    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(profiles) = Profile::get_profile_names() {
-            return Ok(profiles);
-        }
-        Err(Error::Failed(
-            "Failed to get all profile details".to_string(),
-        ))
-    }
-
-    /// Toggle to next platform_profile. Names provided by `Profiles`.
-    /// If fan-curves are supported will also activate a fan curve for profile.
-    fn next_profile(&mut self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.set_next_profile()
-                .unwrap_or_else(|err| warn!("{}", err));
-            ctrl.save_config();
-        }
-        self.do_notification();
-    }
-
-    /// 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(),
-        ))
-    }
-
-    /// Set this platform_profile name as active
-    fn set_active_profile(&self, profile: Profile) {
-        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();
-        }
-        self.do_notification();
-    }
-
-    /// 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 ProfileZbus {
-    fn do_notification(&self) {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            self.notify_profile(&ctrl.config.active_profile)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-}
-
-impl crate::ZbusAdd for ProfileZbus {
-    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();
-    }
-}

daemon/src/ctrl_rog_bios.rs

@@ -1,311 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-use log::{error, info, warn};
-use rog_supported::RogBiosSupportedFunctions;
-use std::fs::OpenOptions;
-use std::io::BufRead;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::process::Command;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
-const DRACUT_PATH: &str = "/usr/bin/dracut";
-
-static ASUS_SWITCH_GRAPHIC_MODE: &str =
-    "/sys/firmware/efi/efivars/AsusSwitchGraphicMode-607005d5-3f75-4b2e-98f0-85ba66797a3e";
-static ASUS_POST_LOGO_SOUND: &str =
-    "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
-
-pub struct CtrlRogBios {
-    _config: Arc<Mutex<Config>>,
-}
-
-impl GetSupported for CtrlRogBios {
-    type A = RogBiosSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        RogBiosSupportedFunctions {
-            post_sound_toggle: Path::new(ASUS_POST_LOGO_SOUND).exists(),
-            dedicated_gfx_toggle: Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists(),
-        }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlRogBios {
-    pub fn set_dedicated_graphic_mode(&mut self, 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
-            })
-            .ok();
-    }
-
-    pub fn dedicated_graphic_mode(&self) -> i8 {
-        Self::get_gfx_mode()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_gfx_mode {}", err);
-                err
-            })
-            .unwrap_or(-1)
-    }
-
-    #[dbus_interface(signal)]
-    pub fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()> {}
-
-    pub fn set_post_boot_sound(&mut self, 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();
-    }
-
-    pub fn post_boot_sound(&self) -> i8 {
-        Self::get_boot_sound()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_boot_sound {}", err);
-                err
-            })
-            .unwrap_or(-1)
-    }
-
-    #[dbus_interface(signal)]
-    pub fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()> {}
-}
-
-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();
-    }
-}
-
-impl crate::Reloadable for CtrlRogBios {
-    fn reload(&mut self) -> Result<(), RogError> {
-        Ok(())
-    }
-}
-
-impl CtrlRogBios {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        if Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists() {
-            CtrlRogBios::set_path_mutable(ASUS_SWITCH_GRAPHIC_MODE)?;
-        } else {
-            info!("G-Sync Switchable Graphics not detected");
-            info!("If your laptop is not a G-Sync enabled laptop then you can ignore this. Standard graphics switching will still work.");
-        }
-
-        if Path::new(ASUS_POST_LOGO_SOUND).exists() {
-            CtrlRogBios::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
-        } else {
-            info!("Switch for POST boot sound not detected");
-        }
-
-        Ok(CtrlRogBios { _config: config })
-    }
-
-    fn set_path_mutable(path: &str) -> Result<(), RogError> {
-        let output = Command::new("/usr/bin/chattr")
-            .arg("-i")
-            .arg(path)
-            .output()
-            .map_err(|err| RogError::Path(path.into(), err))?;
-        info!("Set {} writeable: status: {}", path, output.status);
-        Ok(())
-    }
-
-    pub fn has_dedicated_gfx_toggle() -> bool {
-        Path::new(ASUS_SWITCH_GRAPHIC_MODE).exists()
-    }
-
-    pub fn get_gfx_mode() -> Result<i8, RogError> {
-        let path = ASUS_SWITCH_GRAPHIC_MODE;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
-
-        let idx = data.len() - 1;
-        Ok(data[idx] as i8)
-    }
-
-    pub(super) fn set_gfx_mode(&self, dedicated: bool) -> Result<(), RogError> {
-        let path = ASUS_SWITCH_GRAPHIC_MODE;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)?;
-
-        let idx = data.len() - 1;
-        if dedicated {
-            data[idx] = 1;
-            info!("Set system-level graphics mode: Dedicated Nvidia");
-        } else {
-            data[idx] = 0;
-            info!("Set system-level graphics mode: Optimus");
-        }
-        file.write_all(&data)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        self.update_initramfs(dedicated)?;
-        Ok(())
-    }
-
-    pub fn get_boot_sound() -> Result<i8, RogError> {
-        let path = ASUS_POST_LOGO_SOUND;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
-
-        let idx = data.len() - 1;
-        Ok(data[idx] as i8)
-    }
-
-    pub(super) fn set_boot_sound(on: bool) -> Result<(), RogError> {
-        let path = ASUS_POST_LOGO_SOUND;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
-
-        let idx = data.len() - 1;
-        if on {
-            data[idx] = 1;
-            info!("Set boot POST sound on");
-        } else {
-            data[idx] = 0;
-            info!("Set boot POST sound off");
-        }
-        file.write_all(&data)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        Ok(())
-    }
-
-    // required for g-sync mode
-    fn update_initramfs(&self, dedicated: bool) -> Result<(), RogError> {
-        let mut initfs_cmd = None;
-
-        if Path::new(INITRAMFS_PATH).exists() {
-            let mut cmd = Command::new("update-initramfs");
-            cmd.arg("-u");
-            initfs_cmd = Some(cmd);
-            info!("Using initramfs update command 'update-initramfs'");
-        } else if Path::new(DRACUT_PATH).exists() {
-            let mut cmd = Command::new("dracut");
-            cmd.arg("-f");
-            cmd.arg("-q");
-            initfs_cmd = Some(cmd);
-            info!("Using initramfs update command 'dracut'");
-        }
-
-        if let Some(mut cmd) = initfs_cmd {
-            info!("Updating initramfs");
-
-            // If switching to Nvidia dedicated we need these modules included
-            if Path::new(DRACUT_PATH).exists() && dedicated {
-                cmd.arg("--add-drivers");
-                cmd.arg("nvidia nvidia-drm nvidia-modeset nvidia-uvm");
-                info!("System uses dracut, forcing nvidia modules to be included in init");
-            } else if Path::new(INITRAMFS_PATH).exists() {
-                let modules = vec![
-                    "nvidia\n",
-                    "nvidia-drm\n",
-                    "nvidia-modeset\n",
-                    "nvidia-uvm\n",
-                ];
-
-                let module_include = Path::new("/etc/initramfs-tools/modules");
-
-                if dedicated {
-                    let mut file = std::fs::OpenOptions::new()
-                        .append(true)
-                        .open(module_include)
-                        .map_err(|err| {
-                            RogError::Write(module_include.to_string_lossy().to_string(), err)
-                        })?;
-                    // add nvidia modules to module_include
-                    file.write_all(modules.concat().as_bytes())?;
-                } else {
-                    let file = std::fs::OpenOptions::new()
-                        .read(true)
-                        .open(module_include)
-                        .map_err(|err| {
-                            RogError::Write(module_include.to_string_lossy().to_string(), err)
-                        })?;
-
-                    let mut buf = Vec::new();
-                    // remove modules
-                    for line in std::io::BufReader::new(file).lines().flatten() {
-                        if !modules.contains(&line.as_str()) {
-                            buf.append(&mut line.as_bytes().to_vec());
-                        }
-                    }
-
-                    let file = std::fs::OpenOptions::new()
-                        .write(true)
-                        .open(module_include)
-                        .map_err(|err| {
-                            RogError::Write(module_include.to_string_lossy().to_string(), err)
-                        })?;
-                    std::io::BufWriter::new(file).write_all(&buf)?;
-                }
-            }
-
-            let status = cmd
-                .status()
-                .map_err(|err| RogError::Write(format!("{:?}", cmd), err))?;
-            if !status.success() {
-                error!("Ram disk update failed");
-                return Err(RogError::Initramfs("Ram disk update failed".into()));
-            } else {
-                info!("Successfully updated initramfs");
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_supported.rs

@@ -1,60 +0,0 @@
-use log::warn;
-use serde_derive::{Deserialize, Serialize};
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-use zvariant_derive::Type;
-
-use crate::{
-    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_charge::CtrlCharge,
-    ctrl_profiles::controller::CtrlPlatformProfile, ctrl_rog_bios::CtrlRogBios, GetSupported,
-};
-
-use rog_supported::{
-    AnimeSupportedFunctions, ChargeSupportedFunctions, LedSupportedFunctions,
-    PlatformProfileFunctions, RogBiosSupportedFunctions,
-};
-
-#[derive(Serialize, Deserialize, Type)]
-pub struct SupportedFunctions {
-    pub anime_ctrl: AnimeSupportedFunctions,
-    pub charge_ctrl: ChargeSupportedFunctions,
-    pub platform_profile: PlatformProfileFunctions,
-    pub keyboard_led: LedSupportedFunctions,
-    pub rog_bios_ctrl: RogBiosSupportedFunctions,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl SupportedFunctions {
-    fn supported_functions(&self) -> &SupportedFunctions {
-        self
-    }
-}
-
-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();
-    }
-}
-
-impl GetSupported for SupportedFunctions {
-    type A = SupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        SupportedFunctions {
-            anime_ctrl: CtrlAnime::get_supported(),
-            keyboard_led: CtrlKbdLed::get_supported(),
-            charge_ctrl: CtrlCharge::get_supported(),
-            platform_profile: CtrlPlatformProfile::get_supported(),
-            rog_bios_ctrl: CtrlRogBios::get_supported(),
-        }
-    }
-}

daemon/src/daemon.rs

@@ -1,203 +0,0 @@
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread::sleep;
-use std::time::Duration;
-use std::{env, thread};
-
-use ::zbus::{fdo, Connection, ObjectServer};
-use log::LevelFilter;
-use log::{error, info, warn};
-
-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_profiles::controller::CtrlProfileTask;
-use daemon::ctrl_rog_bios::CtrlRogBios;
-use daemon::error::RogError;
-use daemon::{
-    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
-};
-use daemon::{
-    ctrl_profiles::{controller::CtrlPlatformProfile, zbus::ProfileZbus},
-    laptops::LaptopLedData,
-};
-use daemon::{CtrlTask, Reloadable, ZbusAdd};
-use rog_dbus::DBUS_NAME;
-use rog_profiles::Profile;
-
-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();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    let is_service = match env::var_os("IS_SERVICE") {
-        Some(val) => val == "1",
-        None => false,
-    };
-
-    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);
-
-    start_daemon()?;
-    Ok(())
-}
-
-/// The actual main loop for the daemon
-fn start_daemon() -> Result<(), Box<dyn Error>> {
-    let supported = SupportedFunctions::get_supported();
-    print_board_info();
-    println!("{}", serde_json::to_string_pretty(&supported)?);
-
-    // Start zbus server
-    let connection = Connection::new_system()?;
-    let fdo_connection = fdo::DBusProxy::new(&connection)?;
-    let mut object_server = ObjectServer::new(&connection);
-
-    let config = Config::load();
-    let config = Arc::new(Mutex::new(config));
-
-    supported.add_to_server(&mut object_server);
-
-    match CtrlRogBios::new(config.clone()) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("rog_bios_control: {}", err);
-        }
-    }
-
-    match CtrlCharge::new(config) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("charge_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));
-                ProfileZbus::new(tmp.clone()).add_to_server(&mut object_server);
-
-                let task = CtrlProfileTask::new(tmp);
-                thread::Builder::new().name("profile tasks".into()).spawn(
-                    move || -> Result<(), RogError> {
-                        loop {
-                            task.do_task()?;
-                            sleep(Duration::from_millis(100));
-                        }
-                    },
-                )?;
-            }
-            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()) {
-        Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlAnimeReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("AniMe: {}", err));
-
-            let zbus = CtrlAnimeZbus(inner.clone());
-            zbus.add_to_server(&mut object_server);
-
-            let task = CtrlAnimeTask::new(inner);
-            thread::Builder::new().name("anime tasks".into()).spawn(
-                move || -> Result<(), RogError> {
-                    loop {
-                        task.do_task()?;
-                    }
-                },
-            )?;
-        }
-        Err(err) => {
-            error!("AniMe control: {}", err);
-        }
-    }
-
-    let laptop = LaptopLedData::get_data();
-    let aura_config = AuraConfig::load(&laptop);
-    match CtrlKbdLed::new(laptop, aura_config) {
-        Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlKbdLedReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
-
-            CtrlKbdLedZbus::new(inner.clone()).add_to_server(&mut object_server);
-
-            let task = CtrlKbdLedTask::new(inner);
-            thread::Builder::new().name("keyboard tasks".into()).spawn(
-                move || -> Result<(), RogError> {
-                    loop {
-                        task.do_task()?;
-                    }
-                },
-            )?;
-        }
-        Err(err) => {
-            error!("Keyboard control: {}", err);
-        }
-    }
-
-    // Request dbus name after finishing initalizing all functions
-    fdo_connection.request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-
-    // Loop to check errors and iterate zbus server
-    loop {
-        if let Err(err) = object_server.try_handle_next() {
-            error!("{}", err);
-        }
-    }
-}

daemon/src/laptops.rs

@@ -1,103 +0,0 @@
-use log::{info, warn};
-use rog_aura::AuraModeNum;
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub const ASUS_LED_MODE_CONF: &str = "/etc/asusd/asusd-ledmodes.toml";
-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_family = dmi.product_family().expect("Could not get product_family");
-
-    info!("Product family: {}", prod_family.trim());
-    info!("Board name: {}", board_name.trim());
-}
-
-pub fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModeNum>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect you can edit {}",
-            ASUS_LED_MODE_CONF
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LedSupportFile {
-    led_data: Vec<LaptopLedData>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct LaptopLedData {
-    pub prod_family: String,
-    pub board_names: Vec<String>,
-    pub standard: Vec<AuraModeNum>,
-    pub multizone: bool,
-    pub per_key: bool,
-}
-
-impl LaptopLedData {
-    pub fn get_data() -> Self {
-        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");
-
-        if let Some(modes) = LedSupportFile::load_from_config() {
-            if let Some(data) = modes.matcher(&prod_family, &board_name) {
-                return data;
-            }
-        }
-        info!("Using generic LED control for keyboard brightness only");
-        LaptopLedData {
-            prod_family,
-            board_names: vec![board_name],
-            standard: vec![],
-            multizone: false,
-            per_key: false,
-        }
-    }
-}
-
-impl LedSupportFile {
-    /// Consumes the LEDModes
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<LaptopLedData> {
-        for config in self.led_data {
-            if prod_family.contains(&config.prod_family) {
-                for board in &config.board_names {
-                    if board_name.contains(board) {
-                        info!("Matched to {} {}", config.prod_family, board);
-                        return Some(config);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_CONF) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", ASUS_LED_MODE_CONF);
-                } else {
-                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
-                        panic!("Could not deserialise {}", ASUS_LED_MODE_CONF)
-                    }));
-                }
-            }
-        }
-        warn!("Does {} exist?", ASUS_LED_MODE_CONF);
-        None
-    }
-}

daemon/src/lib.rs

@@ -1,60 +0,0 @@
-#![deny(unused_must_use)]
-/// Configuration loading, saving
-pub mod config;
-/// 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;
-/// Control CPU min/max freq and turbo, fan mode, fan curves
-///
-/// Intel machines can control:
-/// - CPU min/max frequency
-/// - CPU turbo enable/disable
-/// - Fan mode (normal, boost, silent)
-///
-/// AMD machines can control:
-/// - CPU turbo enable/disable
-/// - Fan mode (normal, boost, silent)
-/// - Fan min/max RPM curve
-pub mod ctrl_profiles;
-/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
-pub mod ctrl_rog_bios;
-/// Laptop matching to determine capabilities
-pub mod laptops;
-
-/// Fetch all supported functions for the laptop
-pub mod ctrl_supported;
-
-pub mod error;
-
-use crate::error::RogError;
-use config::Config;
-use zbus::ObjectServer;
-
-pub static VERSION: &str = env!("CARGO_PKG_VERSION");
-
-pub trait Reloadable {
-    fn reload(&mut self) -> Result<(), RogError>;
-}
-
-pub trait ZbusAdd {
-    fn add_to_server(self, server: &mut ObjectServer);
-}
-
-pub trait CtrlTask {
-    fn do_task(&self) -> Result<(), RogError>;
-}
-
-pub trait CtrlTaskComplex {
-    type A;
-
-    fn do_task(&mut self, config: &mut Config, event: Self::A);
-}
-
-pub trait GetSupported {
-    type A;
-
-    fn get_supported() -> Self::A;
-}

data/_asusctl

@@ -1,50 +0,0 @@
-function _asusctl() {
-    local line
-    
-    _arguments -C \
-        {-h,--help}'[print help message]' \
-        {-v,--version}'[print version number]' \
-        {-k,--kbd-bright}':[Set keyboard brightness (off, low, med, high)]' \
-        {-p,--pwr-profile}':[Set power profile (silent, normal, boost)]' \
-        {-c,--chg-limit}':[Set charging limit (20-100)]' \
-        ': :((led-mode\:"Set the keyboard lighting from built-in modes" profile\:"Create and configure profiles" graphics\:"Set the graphics mode"))' \
-        '*::arg:->args'
-    case $line[1] in
-        led-mode)
-            _arguments ': :((static\:"set a single static colour"
-                       breathe\:"pulse between one or two colours"
-                       strobe\:"strobe through all colours"
-                       rainbow\:"rainbow cycling in one of four directions"
-                       star\:"rain pattern mimicking raindrops"
-                       rain\:"rain pattern of three preset colours"
-                       highlight\:"pressed keys are highlighted to fade"
-                       laser\:"pressed keys generate horizontal laser"
-                       ripple\:"pressed keys ripple outwards like a splash"
-                       pulse\:"set a rapid pulse"
-                       comet\:"set a vertical line zooming from left"
-                       flash\:"set a wide vertical line zooming from left"
-                       multi-static\:"4-zone multi-colour"))' \
-                       {-h,--help}'[print help message]' \
-                       '-c:[set the RGB value e.g, ff00ff]' \
-                       '-s:[set the speed (low, med, high)]'
-            ;;
-        profile)
-            _arguments {-h,--help}'[print help message]' \
-                       {-c,--create}"[create the profile if it doesn't exist]" \
-                       {-t,--turbo}':[enable or disable cpu turbo]' \
-                       {-m,--min-percentage}':[set min cpu scaling (intel)]' \
-                       {-M,--max-percentage}':[set max cpu scaling (intel)]' \
-                       {-p,--preset}':[<silent, normal, boost>]' \
-                       {-C,--curve}':[set fan curve]'
-
-            ;;
-        graphics)
-            _arguments {-h,--help}'[print help message]' \
-                       {-m,--mode}':[Set graphics mode (nvidia, hybrid, compute, integrated)]' \
-                       {-g,--get}'[Get the current mode]' \
-                       {-p,--pow}'[Get the current power status]' \
-                       {-f,--force}'[Do not ask for confirmation]'
-            ;;
-    esac
-}
-compdef _asusctl asusctl

data/asus-notify.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=ASUS Notifications
-StartLimitInterval=200
-StartLimitBurst=2
-
-[Service]
-ExecStartPre=/usr/bin/sleep 2
-ExecStart=/usr/bin/asus-notify
-Restart=on-failure
-RestartSec=1
-Type=simple
-
-[Install]
-WantedBy=default.target

data/asusd-alt.service

@@ -1,13 +0,0 @@
-[Unit]
-Description=ASUS Notebook Control
-After=basic.target syslog.target
-
-[Service]
-Environment=IS_SERVICE=1
-ExecStart=/usr/bin/asusd
-Restart=on-failure
-Type=dbus
-BusName=org.asuslinux.Daemon
-
-[Install]
-WantedBy=multi-user.target

data/asusd-ledmodes.toml

@@ -1,133 +0,0 @@
-[[led_data]]
-prod_family = "Zephyrus S"
-board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
-per_key = true
-
-[[led_data]]
-prod_family = "Zephyrus M"
-board_names = ["GU502GV"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-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"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = false
-per_key = false
-
-[[led_data]]
-prod_family = "Zephyrus"
-board_names = ["GM501GM", "GX531"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G531GW", "G533QR", "G533QS", "G733QS", "G733QR", "G513QR", "G713QR"]
-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", "G513IH", "G513QY", "G713QM"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G512LI", "G712LI", "G531GD"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = false
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GV", "G731GW", "G531GV"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = true
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = false
-per_key = false
-
-[[led_data]]
-prod_family = "Strix Scar"
-board_names = ["G531", "G731"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = true
-per_key = true
-
-[[led_data]]
-prod_family = "ROG"
-board_names = ["GL553VE"]
-standard = ["Static", "Breathe", "Strobe"]
-multizone = true
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G14"
-board_names = ["GA401Q"]
-standard = ["Static", "Breathe", "Pulse"]
-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"]
-standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
-multizone = false
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus"
-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

data/asusd.conf

@@ -3,24 +3,24 @@
           "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
 <busconfig>
     <policy group="adm">
-        <allow send_destination="org.asuslinux.Daemon"/>
-        <allow receive_sender="org.asuslinux.Daemon"/>
+        <allow send_destination="xyz.ljones.Asusd"/>
+        <allow receive_sender="xyz.ljones.Asusd"/>
     </policy>
     <policy group="sudo">
-        <allow send_destination="org.asuslinux.Daemon"/>
-        <allow receive_sender="org.asuslinux.Daemon"/>
+        <allow send_destination="xyz.ljones.Asusd"/>
+        <allow receive_sender="xyz.ljones.Asusd"/>
     </policy>
     <policy group="users">
-        <allow send_destination="org.asuslinux.Daemon"/>
-        <allow receive_sender="org.asuslinux.Daemon"/>
+        <allow send_destination="xyz.ljones.Asusd"/>
+        <allow receive_sender="xyz.ljones.Asusd"/>
     </policy>
     <policy group="wheel">
-        <allow send_destination="org.asuslinux.Daemon"/>
-        <allow receive_sender="org.asuslinux.Daemon"/>
+        <allow send_destination="xyz.ljones.Asusd"/>
+        <allow receive_sender="xyz.ljones.Asusd"/>
     </policy>
     <policy user="root">
-        <allow own="org.asuslinux.Daemon"/>
-        <allow send_destination="org.asuslinux.Daemon"/>
-        <allow receive_sender="org.asuslinux.Daemon"/>
+        <allow own="xyz.ljones.Asusd"/>
+        <allow send_destination="xyz.ljones.Asusd"/>
+        <allow receive_sender="xyz.ljones.Asusd"/>
     </policy>
 </busconfig>