Prep 4.5.6 release

Closes #293

.gitignore

@@ -1,2 +1,9 @@
 /target
-vendor.tar.xz
+vendor.tar.xz
+cargo-config
+.idea
+vendor
+vendor-*
+vendor_*
+.vscode-ctags
+.vscode

.gitlab-ci.yml

@@ -1,26 +1,63 @@
-image: rustdocker/rust:stable
+image: rust:latest
+
+cache:
+  key: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
+  paths:
+      # Don't include `incremental` to save space
+      # Debug
+      - target/debug/build/
+      - target/debug/deps/
+      - target/debug/.fingerprint/
+      - target/debug/.cargo-lock
+      - target/debug/df_storyteller
+      # Release
+      - target/release/build/
+      - target/release/deps/
+      - target/release/.fingerprint/
+      - target/release/.cargo-lock
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep
 
 stages:
+    - format
+    - check
     - test
-    - build
+    - release
+
+format:
+  except:
+    - tags
+  script:
+    - echo "nightly" > rust-toolchain
+    - rustup component add rustfmt
+    - cargo fmt --check
+
+check:
+  except:
+    - tags
+  script:
+    - rustup component add clippy
+    - cargo check
+    # deny currently catches too much
+    #- cargo install cargo-deny && cargo deny
+    - cargo install cargo-cranky && cargo cranky
 
 test:
+  except:
+    - tags
   script:
-    - cargo check #+nightly check --features "clippy"
+    - cargo test
 
-build:
+release:
   only:
-    - main
+    - tags
   script:
     - make && make vendor
   artifacts:
     paths:
-    - vendor_asus-nb-ctrl_*.tar.xz
+    - vendor_asusctl_*.tar.xz
     - cargo-config
 
 variables:
   GIT_SUBMODULE_STRATEGY: normal
-

CHANGELOG.md

@@ -5,6 +5,345 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [v4.5.6]
+### Changed
+- Fix tasks not always running correctly on boot/sleep/wake/shutdown by finishing the move to async
+- Change how the profile/fan change task monitors changes due to TUF laptops behaving slightly different
+- ROGCC: Better handle the use of GPU MUX without supergfxd
+- ROGCC: Track if reboot required when not using supergfxd
+- Add env var for logging levels to daemon and gui (`RUST_LOG=<error|warn|info|debug|trace>`)
+- ROGCC: Very basic support for running a command on AC/Battery switching, this is in config at `~/.config/rog/rog-control-center.cfg`, and for now must be edited by hand and ROGCC restarted (run ROGCC in BG to use effectively)
+  + Run ROGCC from terminal to see errors of the AC/Battery command
+  + Support for editing via ROGCC GUI will come in future
+  + This is ideal for userspace tasks
+- asusd: Very basic support for running a command on AC/Battery switching, this is in config at `/etc/asusd/asusd.conf`. A restart of asusd is not required if edited.
+  + This is ideal for tasks that require root access (BE SAFE!)
+- The above AC/Battery commands are probably best set to run a script for more complex tasks
+- asusd: check if nvidia-powerd enabled before toggling
+        
+## [v4.5.5]
+### Changed
+- remove an unwrap() causing panic on main ROGCC thread
+
+## [v4.5.4]
+### Changed
+- ROGCC:: Allow ROGCC to run without supergfxd
+- ROGCC: Tray/notifs now reads dGPU status directly via supergfx crate (supergfxd not required)
+- Add rust-toolchain to force minimum rust version
+
+## [v4.5.3]
+### Changed
+- Adjust how fan graph in ROGCC works, deny incorrect graphs
+- Fix to apply the fan curve change in ROGCC to the correct profile
+- Support for G713RS LED modes (Author: Peter Ivanov)
+- Support for G713RM LED modes (Author: maxbachmann)
+- Fix VivoBook detection
+- Update dependencies to get latest winit crate (fixes various small issues)
+
+## [v4.5.2]
+### Changed
+- Update dependencies and bump version
+
+## [v4.5.1]
+### Added
+- Support for FA506IE LED modes (Author: Herohtar)
+### Changed
+- Add a basic system tray with dGPU status and gpu mode switch actions
+- Fixup some notifications in ROGCC
+- Add config options for notifications for ROGCC
+- Share states with tray process in ROGCC
+- Share tates with tray process in ROGCC
+
+## [v4.5.0]
+### Added
+- intofy watches on:
+  - `charge_control_end_threshold`
+  - `panel_od`
+  - `gpu_mux_mode`
+  - `platform_profile`
+  - keyboard brightness
+  - These allow for updating any associated config and sending dbus notifications.
+- New dbus methods
+  - `DgpuDisable`
+  - `SetDgpuDisable`
+  - `NotifyDgpuDisable`
+  - `EgpuEnable`
+  - `SetEgpuEnable`
+  - `NotifyEgpuEnable`
+  - `MainsOnline` (This is AC, check if plugged in or not)
+  - `NotifyMainsOnline`
+- `nvidia-powerd.service` will now enable or disable depending on the AC power state
+  and on resume/boot (hybrid boot). It has been proven that this nvidia daemon can be
+  problematic when on battery, not allowing the dgpu to suspend within decent time and
+  sometimes blocking it completely.
+- Notification to rog-control-center of dGPU state change
+### Changed
+- Use loops to ensure that mutex is gained for LED changes.
+- asusctl now uses tokio for async runtime. This helps simplify some code.
+- Properly fix notifs used in rog-control-center
+### Breaking
+- DBUS: all charge control methods renamed to:
+  - `ChargeControlEndThreshold`
+  - `SetChargeControlEndThreshold`
+  - `NotifyChargeControlEndThreshold`
+- DBUS: all panel overdrive methods renamed to:
+  - `PanelOd` (from PanelOverdrive)
+  - `SetPanelOd`
+  - `NotifyPanelOd`
+  - Path `/org/asuslinux/Charge` changed to `/org/asuslinux/Power`
+
+## [v4.4.0] - 2022-08-29
+### Added
+- Support for per-key config has been added to `asusd-user`. At the moment it is
+  basic with only a few effects done. Please see the manual for more information.
+- Support for unzoned and  per-zone effects on some laptops. As above.
+- Added three effects to use with Zoned or Per-Key:
+  + Static, Breathe, Flicker. More to come.
+- Support for G713RS LED modes
+- Support for TUF laptop RGB (kernel patches required, these are submitted upstream)
+### Changed
+- Create new rog-platform crate to manage all i/o in a universal way
+  + kbd-led handling (requires kernel patches, TUF specific)
+  + platform handling (asus-nb-wmi)
+  + power (basic, can be extended in future)
+  + hidraw
+  + usbraw
+- Refactor how ROGCC handles IPC for background open, run-in-bg
+- Refactor daemon task creation to be simpler (for development)
+- Rename dpu_only to gpu_mux. Update all related messages and info.
+### Breaking
+- DBUS: rename path `/org/asuslinux/RogBios` to `/org/asuslinux/Platform`
+- DBUS: renamed `dedicated_graphic_mode` to `gpu_mux_mode` (`GpuMuxMode`)
+- DBUS: renamed `set_dedicated_graphic_mode` to `set_gpu_mux_mode` (`SetGpuMuxMode`)
+  + The methods above take an enum: 0 = Discrete, 1 = Optimus
+
+## [4.3.4] - 2022-08-03
+### Bugfix
+- ROGCC: Remove power setting from correct array
+
+## [4.3.3] - 2022-08-02
+### Added
+- `rog-control-center` has now been moved in to the main workspace due to
+  the heavy dependencies on most of the rog crates
+- Preliminary support of TUF RGB keyboards + power states
+- Support for G713RW LED modes (Author: jarvis2709)
+- Support for G713IC LED modes
+### Changed
+- The udev rules have been changed to make asusd load with all gamer variants when asus-nb-wmi is loaded
+  - TUF, ROG, Zephyrus, Strix
+
+## [4.3.0] - 2022-07-21
+### Added
+- Clear command for anime `asusctl anime --clear` will clear the display
+- Re-added support for LED power states on `0x1866` type keyboards
+### Changed
+- Make rog-anime more error tolerent. Remove various asserts and return errors instead
+- Return error if a pixel-gif is larger than the anime-display dimensions
+- Both Anime and Aura dbus interfaces are changed a little
+  - Aura power has changed, all power related settings are now in one method
+  - Anime methods will now return an error (if errored)
+  - /org/asuslinux/Led renamed to /org/asuslinux/Aura
+
+## [4.2.1] - 2022-07-18
+### Added
+- Add panel overdrive support (autodetects if supported)
+- Add detection of dgpu_disable and egpu_enable for diagnostic
+### Changed
+- Fixed save and restore of multizone LED settings
+- Create defaults for multizone
+
+## [4.2.0] - 2022-07-16
+### Added
+- Support for GA402 Anime Matrix display (Author: I-Al-Istannen & Luke Jones)
+- Support for power-config of all LED zones. See `asusctrl led-power --help` (Author: Luke Jones, With much help from: @MNS26)
+- Full support for multizone LED <logo, keyboard, lightbar> (Author: Luke Jones, With much help from: @MNS26)
+- Add ability to load extra data from `/etc/asusd/asusd-user-ledmodes.toml` for LED support if file exits
+- Support for G513IM LED modes
+- Support for GX703HS LED modes
+### Changed
+- Dbus interface for Aura config has been changed, all power control is done with `SetLedsEnabled` and `SetLedsDisabled`
+- Data for anime-matrix now requires passing the laptop model as enum
+- Extra unit tests for anime stuff to help verify things
+
+### Added
+- Support for GA503R LED modes
+### Changed
+- Refactor LED and AniMe tasks
+- Reload keyboard brightness on resume from sleep/hiber
+
+## [4.1.1] - 2022-06-21
+### Changed
+- Fixes to anime matrix system thread cancelation
+
+## [4.1.0] - 2022-06-20
+### Changed
+- Huge refactor to use zbus 2.2 + zvariant 3.0 in system-daemon.
+- Daemons with tasks now use `smol` for async ops.
+- Fixes to fan-curve settings from CLI (Author: Armas Span)
+- Add brightness to anime zbus notification
+- Adjust how threads in AniMe matrix controller work
+- Use proper power-state packet for keyboard LED's (Author: Martin Piffault)
+### Added
+- Support for GA402R LED modes
+- Support for GU502LV LED modes
+- Support for G512 LED modes
+- Support for G513IC LED modes (Author: dada513)
+- Support for G513QM LED modes (Author: Martin Piffault)
+- Add side-LED toggle support (Author: Martin Piffault)
+- Support reloading keyboard mode on wake (from sleep/hiber)
+- Support reloading charge-level on wake (from sleep/hiber)
+- Support running AniMe animation blocks on wake/sleep and boot/shutdown events
+
+# [4.0.7] - 2021-12-19
+### Changed
+- Fix incorrect power-profile validation
+- Update asusd-ledmodes.toml to support Asus Rog Strix G15 G513QE (@LordVicky)
+- Update patch notes and links
+
+# [4.0.6] - 2021-11-01
+### Changed
+- Fix CLI for bios toggles
+### Added
+- Extra commands for AniMe: pixel-image, gif, pixel-gif
+
+# [4.0.5] - 2021-10-27
+### Changed
+- Convert fan curve percentage to 0-255 expected by kernel driver only if '%' char is used, otherwise the expected range for fan power is 0-255
+- Use correct error in daemon for invalid charging limit
+- Enforce charging limit values in range 20-100
+### Added
+- LED modes for G513QR
+
+# [4.0.4] - 2021-10-02
+### Changed
+- Add missing Profile commands
+- Spawn tasks on individual threads to prevent blocking
+- Don't force fan-curve default on reload
+- Begin obsoleting the graphics switch command in favour of supergfxctl
+- Slim down the notification daemon to pure ASUS notifications
+
+# [4.0.3] - 2021-09-16
+### Changed
+- Don't show fan-curve warning if fan-curve available
+- Add G713QR to Strix led-modes
+- Fix part of CLI fan-curve control
+
+# [4.0.2] - 2021-09-14
+### Changed
+- Backup old configs to *-old if parse fails
+- Prevent some types of crashes related to unpatched kernels
+- Add better help for graphics errors
+- Add better help for asusctl general errors
+- Implement fan-curve dbus API
+- Implement partial fan-curve control via CLI tool
+  + Set fan curve for profile + fan gpu/cpu
+
+# [4.0.1] - 2021-09-11
+### Changed
+- Fix asusd-ledmodes.toml
+
+# [4.0.0] - 2021-09-10
+### Added
+- AniMe:
+  + Support 8bit RGB, RGBA, 16bit Greyscalw, RGB, RGBA
+  + add `AsusImage` type for slanted-template pixel-perfect images
+  + `BREAKING:` plain `Image` with time period is changed and old anime configs break as a result (sorry)
+- LED:
+  + By popular request LED prev/next cycle is added
+  + Add led modes for GX551Q
+### BREAKING CHANGES
+- Graphics control:
+  + graphics control is pulled out of asusd and moved to new package; https://gitlab.com/asus-linux/supergfxctl
+- Proflies:
+  + profiles now depend on power-profile-daemon plus kernel patches for support of platform_profile
+    - if your system supports fan-curves you will also require upcoming kernel patches for this
+  + profiles are now moved to a new file
+  + fan-curves are only partially completed due to this release needing to be done sooner
+
+# [3.7.2] - 2021-08-02
+### Added
+- Enable multizone support on Strix 513IH
+- Add G513QY ledmodes
+### Changed
+- Fix missing CLI command help for some supported options
+- Fix incorrectly selecting profile by name, where the active profile was being copied to the selected profile
+- Add `asusd` version back to `asusctl -v` report
+- Fix various clippy warnings
+
+# [3.7.1] - 2021-06-11
+### Changed
+- Refine graphics mode switching:
+  + Disallow switching to compute or vfio mode unless existing mode is "Integrated"
+
+# [3.7.0] - 2021-06-06
+### Changed
+- Set PM to auto for Nvidia always
+- Extra info output for gfx dev scan
+- Extra info in log for G-Sync to help prevent user confusion around gfx switching
+- Add GA503Q led modes
+- Added ability to fade in/out gifs and images for anime. This does break anime configs. See manual for details.
+- Added task to CtrlLed to set the keyboard LED brightness on wake from suspend
+  + requires a kernel patch which will be upstreamed and in fedora rog kernel
+- Make gfx change from nvidia to vfio/compute also force-change to integrated _then_
+  to requested mode
+- Fix invalid gfx status when switching from some modes
+- Fix copy over of serde skipped config values on config reload
+
+# [3.6.1] - 2021-05-25
+### Changed
+- Bugfix: write correct fan modes for profiles
+- Bugfix: apply created profiles
+
+# [3.6.1] - 2021-05-25
+### Changed
+- Bugfix for cycling through profiles
+
+# [3.6.0] - 2021-05-24
+### Changed
+- Add GX550L led modes
+- Don't save compute/vfio modes. Option in config for this is removed.
+- Store a temporary non-serialised option in config for if compute/vfio is active
+  for informational purposes only (will not apply on boot)
+- Save state for LEDs enabled + sleep animation enabled
+- Save state for AnimMe enabled + boot animation enabled
+- Add extra config options and dbus methods
+- Add power state signals for anime and led
+- Refactor to use channels for dbus signal handler send/recv
+- Split out profiles independant parts to a rog-profiles crate
+- Cleanup dependencies
+- Fix some dbus Supported issues
+
+# [3.5.2] - 2021-05-15
+### Changed
+- Bugfix: prevent the hang on compute/integrated mode change
+
+# [3.5.1] - 2021-04-25
+### Changed
++ Anime:
+  - Fix using multiple configs
+
+# [3.5.0] - 2021-04-25
+### Changed
++ Keyboard:
+  - Split out all aura functionality that isn't dependent on the daemon in to a
+    new crate `rog-aura` (incomplete)
+  - Keyboard LED control now includes:
+    + Enable/disable LED's while laptop is awake
+    + Enable/disable LED animation while laptop is suspended and AC plugged in
+  - Properly reload the last used keyboard mode on boot
++ Graphics:
+  - Correctly enable compute mode for nvidia plus no-reboot or logout if switching
+    from vfio/integrated/compute.
+  - Add asusd config option to not save compute/vfio mode switch.
++ Anime:
+  - Enable basic multiple user anime configs (asusd-user must still be restarted)
++ Profiles:
+  - Enable dbus methods for freq min/max, fan curve, fan preset, CPU turbo enable.
+    These options will apply to the active profile if no profile name is specified.
+
+# [3.4.1] - 2021-04-11
+### Changed
+- Fix anime init sequence
 
 # [3.4.0] - 2021-04-11
 ### Changed
@@ -12,7 +351,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Use enum to show power states, and catch missing pci path for nvidia.
 - Partial user-daemon for anime/per-key done, `asusd-user`. Includes asusd-user systemd unit.
 - user-daemon provides dbus emthods to insert anime actions, remove from index, set leds on/off
-  + COnfig file is stored in `~/.config/rog/rog-user.cfg`
+  + Config file is stored in `~/.config/rog/rog-user.cfg`
 - AniMe display parts split out to individual crate in preparation for publishing
   on crates.io
 

Cargo.toml

@@ -1,14 +1,51 @@
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-types", "rog-dbus", "rog-anime"]
+members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+
+[workspace.package]
+version = "4.5.6"
+
+[workspace.dependencies]
+async-trait = "^0.1"
+tokio = { version = "^1.22.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^1.3"
+
+zbus = "^3.5"
+logind-zbus = { version = "^3.0.3" } #, default-features = false, features = ["non_blocking"] }
+
+serde = "^1.0"
+serde_derive = "^1.0"
+serde_json = "^1.0"
+toml = "^0.5.9"
+
+log = "^0.4"
+env_logger = "^0.10.0"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = "^0.7"
+rusb = "^0.9"
+sysfs-class = "^0.1.3"
+inotify = "^0.10.0"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.4.0"
+gif = "^0.12.0"
+
+notify-rust = { git = "https://github.com/flukejones/notify-rust.git", default-features = false, features = ["z"] }
 
 [profile.release]
-lto = true
+# thin = 57s, asusd = 9.0M
+# fat = 72s, asusd = 6.4M
+lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"
 
 [profile.dev]
-debug = false
+debug = true
 opt-level = 1
 
 [profile.bench]

Cranky.toml

@@ -0,0 +1,121 @@
+# https://github.com/ericseppanen/cargo-cranky
+# cargo install cargo-cranky && cargo cranky
+
+warn = [
+  "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

@@ -0,0 +1,454 @@
+# asusctrl manual
+
+`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.
+
+## Programs Available
+
+- `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.
+
+The functionality that `asusd` exposes is:
+
+- anime control
+- led keyboard control (aura)
+- charge limiting
+- bios/efivar control
+- power profile switching
+- fan curves (if supported, this is auto-detected)
+
+each of these will be detailed in sections.
+
+### AniMe control
+
+Controller for the fancy AniMe matrix display on the lid of some machines. This controller is a work in progress.
+
+#### Config options
+
+If you have an AniMe device a few system-level config options are enabled for you in `/etc/asusd/anime.conf`;
+
+1. `"system": [],`: currently unused, is intended to be a default continuous sequence in future versions
+2. `"boot": [],`: a sequence that plays on system boot (when asusd is loaded)
+3. `"wake": [],`: a sequence that plays when waking from suspend
+4. `"shutdown": [],`: a sequence that plays when shutdown begins
+5. `"brightness": <FLOAT>`: global brightness control, where `<FLOAT> is 0.0-1.0
+
+Some default examples are provided but are minimal. The full range of configuration options will be covered in another section of this manual.
+
+### Led keyboard control
+
+The LED controller (e.g, aura) enables setting many of the factory modes available if a laptop supports them. It also enables per-key RGB settings but this is a WIP and will likely be similar to how AniMe sequences can be created.
+
+#### 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 = "Strix"
+board_names = ["GL504G"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
+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 models have 4 to 7 zones of LED control as shown in the example. If the laptop has no zones then an empty array will suffice.
+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.
+
+### Charge control
+
+Almost all modern ASUS laptops have charging limit control now. This can be controlled in `/etc/asusd/asusd.conf`.
+
+```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 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.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/10/23/250) which is accepted for the 5.17 kernel release .
+
+The fan curve format can be of varying formats:
+
+- `30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"`
+- `30:0,40:5,50:10,60:20,70:35,80:55,90:65,100:65"`
+- `30 0,40 5,50 10,60 20,70 35,80 55,90 65,100 65"`
+- `30 0 40 5 50 10 60 20 70 35 80 55 90 65 100 65"`
+
+the order must always be the same "temperature:percentage", lowest from left to rigth being highest.
+
+The config file is located at `/etc/asusd/profile.conf` and is self-descriptive. On first run it is populated with the system EC defaults.
+
+### Support controller
+
+There is one more controller; the support controller. The sole pupose of this controller is to querie all the other controllers for information about their support level for the host laptop. Returns a json string.
+
+## 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.
+
+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:
+
+```json
+{
+  "name": "aura-default",
+  "aura": [
+    {
+      "Breathe": {
+        "led_type": {
+          "Key": "W"
+        },
+        "start_colour1": [
+          255,
+          0,
+          20
+        ],
+        "start_colour2": [
+          20,
+          255,
+          0
+        ],
+        "speed": "Low"
+      }
+    },
+    {
+      "Static": {
+        "led_type": {
+          "Key": "Esc"
+        },
+        "colour": [
+          0,
+          0,
+          255
+        ]
+      }
+    },
+    {
+      "Flicker": {
+        "led_type": {
+          "Key": "N9"
+        },
+        "start_colour": [
+          0,
+          0,
+          255
+        ],
+        "max_percentage": 80,
+        "min_percentage": 40
+      }
+    }
+  ]
+}
+```
+
+If your laptop supports multizone, `"led_type"` can also be `"Zone": <one of the following>`
+- `"None"`
+- `"KeyboardLeft"`
+- `"KeyboardCenterLeft"`
+- `"KeyboardCenterRight"`
+- `"KeyboardRight"`
+- `"LightbarRight"`
+- `"LightbarRightCorner"`
+- `"LightbarRightBottom"`
+- `"LightbarLeftBottom"`
+- `"LightbarLeftCorner"`
+- `"LightbarLeft"`
+
+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.
+
+**Aura layouts**: `asusd-user` does its best to find a suitable layout to use based on `/sys/class/dmi/id/board_name`.
+It looks at each of the files in `/usr/share/rog-gui/layouts/` and matches against the toml block looking like:
+```toml
+matches = [
+    'GX502',
+    'GU502',
+]
+```
+
+My laptop is a `GX502GW`, so `GX502` is a match. Note that these layouts are the physical representation of
+the keyboard and are used in the GUI also. The config that tells if per-key is supported is located in
+`/etc/asusd/asusd-ledmodes.toml`
+
+#### 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"`
+
+An AniMe config itself is a file with contents:
+
+```json
+{
+  "name": "<FILENAME>",
+  "anime": []
+}
+```
+
+`<FILENAME>` is used as a reference internally. `"anime": []` is an array of sequences (WIP).
+
+##### "anime" array options
+
+Each object in the array can be one of:
+
+1. AsusAnimation
+2. ImageAnimation
+3. Image
+4. Pause
+
+##### 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>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### AsusImage
+
+Virtually the same as `AsusAnimation` but for png files, typically created in the same "slanted" style using a template (`diagonal-template.png`) as the ASUS gifs for pixel perfection.
+
+```json
+      "AsusImage": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### ImageAnimation
+
+`ImageAnimation` can play *any* gif of any size.
+
+```json
+      "ImageAnimation": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Image
+
+`Image` currently requires 8bit greyscale png. It will be able to use most in future.
+
+```json
+    {
+      "Image": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Pause
+
+A `Pause` is handy for after an `Image` to hold the `Image` on the AniMe for a period.
+
+```json
+    {
+      "Pause": {
+        "secs": <INT>,
+        "nanos": <INT>
+      }
+    },
+```
+
+##### Options for objects
+
+**<FILE_PATH>**
+
+Must be full path: `"/usr/share/asusd/anime/asus/gaming/Controller.gif"` or `/home/luke/Downloads/random.gif`.
+
+**<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
+- `translation`: Shift the image X -/+, and y -/+
+
+**<TIME>**
+
+Time is the length of time to run the gif for:
+```json
+        "time": {
+          "Time": {
+            "secs": 5,
+            "nanos": 0
+          }
+        },
+```
+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": {
+            "fade_in": {
+              "secs": 2,
+              "nanos": 0
+            },
+            "show_for": {
+              "secs": 1,
+              "nanos": 0
+            },
+            "fade_out": {
+              "secs": 2,
+              "nanos": 0
+            }
+          }
+        },
+```
+`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).
+
+**<INT>**
+
+A plain non-float integer.
+
+## asusctl
+
+`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.
+
+Most commands are self-explanatory.
+
+### CLI Usage and help
+
+Commands are given by:
+
+```
+asusctl <option> <command> <command-options>
+```
+
+Help is available through:
+
+```
+asusctl --help
+asusctl <command> --help
+```
+
+Some commands may have subcommands:
+
+```
+asusctl <command> <subcommand> --help
+```
+
+### Keybinds
+
+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
+```
+**Previous**
+```
+asusctl led-mode -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)
+
+---
+
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+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,13 +11,11 @@ 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
-X11CFG := 90-nvidia-screen-G05.conf
-PMRULES := 90-asusd-nvidia-pm.rules
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
@@ -41,42 +39,60 @@ distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
 install:
+	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	$(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 "*.toml" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
+
 	$(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)"
+
-	$(INSTALL_DATA) "./data/$(PMRULES)" "$(DESTDIR)$(libdir)/udev/rules.d/$(PMRULES)"
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	$(INSTALL_DATA) "./data/$(LEDCFG)" "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
-	$(INSTALL_DATA) "./data/$(X11CFG)" "$(DESTDIR)$(datarootdir)/X11/xorg.conf.d/$(X11CFG)"
+
 	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	$(INSTALL_DATA) "./data/$(BIN_N).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+
 	$(INSTALL_DATA) "./data/icons/asus_notif_yellow.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_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/_asusctl" "$(DESTDIR)$(zshcpl)/_asusctl"
+	$(INSTALL_DATA) "./data/icons/asus_notif_orange.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_orange.png"
-	$(INSTALL_DATA) "./data/completions/asusctl.fish" "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
+	$(INSTALL_DATA) "./data/icons/asus_notif_white.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_white.png"
-	cd data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-compute.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-hybrid.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-integrated.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-nvidia.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+
+	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
 
 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/$(PMRULES)"
 	rm -f "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
-	rm -f "$(DESTDIR)$(datarootdir)/X11/xorg.conf.d/$(X11CFG)"
 	rm -f "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	rm -r "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
-	rm -f "$(DESTDIR)$(zshcpl)/_asusctl"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
-	rm -f "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
 	rm -rf "$(DESTDIR)$(datarootdir)/asusd"
+	rm -rf "$(DESTDIR)$(datarootdir)/rog-gui"
 
 update:
 	cargo update
@@ -96,5 +112,9 @@ ifeq ($(VENDORED),1)
 	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
+	strip -s ./target/release/$(BIN_C)
+	strip -s ./target/release/$(BIN_D)
+	strip -s ./target/release/$(BIN_U)
+	strip -s ./target/release/$(BIN_ROG)
 
 .PHONY: all clean distclean install uninstall update build

README.md

@@ -1,34 +1,35 @@
-# ASUS NB Ctrl
+# `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/)
 
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel, or v6.1 which has all my work merged upstream.
+
 `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.
 
+Now includes a GUI, `rog-control-center`.
+
+## Kernel support
+
+**The minimum supported kernel version is 5.17**
+
 ## 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
 
 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. All other distros are *not* supported (while asusd might still run fine on them).
-supported (while asusd might still run fine on them). For best support use fedora 32+ Workstation.
+For best support use fedora 36+ Workstation.
 
-**NOTICE:**
+Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
-1. The following is *not* required for 5.11 kernel versions, as this version includes all the required patches.
+a system-level daemon should.
-2. 2021 hardware has a new keyboard prod_id and the patch is included in 5.12+
-
-'hid-asus-rog` DKMS module from [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/).
-
-The module enables the following in kernel:
-
-- Initialising the keyboard
-- All hotkeys (FN+Key combos)
 
 ## Discord
 
-[Discord server link](https://discord.gg/ngbdKabAnP)
+[Discord server link](https://discord.gg/4ZKGd7Un5t)
 
 ## SUPPORTED LAPTOPS
 
@@ -40,133 +41,65 @@ Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
 
 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
+and AniMe parts should work regardless of your latop make.
-will probably suffer another rename once it becomes generic enough to do so.
+
+**TUF Laptops**: now supported provided the kernel is patched. These patches are submitted upstream and will be in version 6.1.x of the kernel (or thereabouts). See the blog on asus-linux.org for more info.
 
 ## Implemented
 
 - [X] System daemon
+- [X] GUI app
 - [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] Logging - required for journalctl
+- [X] AniMatrix display on G14 models that include it
-- [X] AniMatrix display on G14 models that include it (currently being reworked)
 - [X] Set battery charge limit (with kernel supporting this)
-- [X] Fan curve control on G14 + G15 thanks to @Yarn1
+- [X] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
-- [X] Graphics mode switching between iGPU, dGPU, on-demand, and vfio (for VM pass-through)
-  + [X] Requires only a logout/login
 - [X] Toggle bios setting for boot/POST sound
-- [X] Toggle bios setting for "dedicated gfx" mode on supported laptops (g-sync)
+- [X] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
-# FUNCTIONS
+# GUI
 
-## Graphics switching
+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.
 
-`asusd` can switch graphics modes between:
+![](/extra/system.png)
-- `integrated`, uses the iGPU only and force-disables the dGPU
+![](/extra/fan-curves.png)
-- `hybrid`, enables Nvidia prime-offload mode
+![](/extra/keyboard.png)
-- `nvidia`, uses the Nvidia gpu only
-- `vfio`, binds the Nvidia gpu to vfio for VM pass-through
-
-**Rebootless note:** You must edit `/etc/default/grub` to remove `nvidia-drm.modeset=1`
-from the line `GRUB_CMDLINE_LINUX=` and then recreate your grub config. In fedora
-you can do this with `sudo grub2-mkconfig -o /etc/grub2.cfg` - other distro may be
-similar but with a different config location.
-
-This can be disabled in the config with `"manage_gfx": false,`. Additionally there
-is an extra setting for laptops capable of g-sync dedicated gfx mode to enable the
-graphics switching to switch on dedicated gfx for "nvidia" mode.
-
-This switcher conflicts with other gpu switchers like optimus-manager, suse-prime
-or ubuntu-prime, system76-power, and bbswitch. If you have issues with `asusd`
-always defaulting to `integrated` mode on boot then you will need to check for
-stray configs blocking nvidia modules from loading in:
-- `/etc/modprobe.d/`
-- `/usr/lib/modprope.d/`
-
-**VFIO NOTE:** The vfio modules *must not* be compiled into the kernel, they need
-to be separate modules. If you don't plan to use vfio mode then you can ignore this
-otherwise you may need a custom built kernel.
-
-To enable vfio switching you need to edit `/etc/asusd/asusd.conf` and change `"gfx_vfio_enable": false,` to true.
-
-### Power management udev rule
-
-If you have installed the Nvidia driver manually you will require the
-`data/90-asusd-nvidia-pm.rules` udev rule to be installed in `/etc/udev/rules.d/`.
-
-### fedora and openSUSE
-
-You *may* need a file `/etc/dracut.conf.d/90-nvidia-dracut-G05.conf` installed
-to stop dracut including the nvidia modules in the ramdisk if you manually
-installed the nvidia drivers.
-
-```
-# filename /etc/dracut.conf.d/90-nvidia-dracut-G05.conf
-# Omit the nvidia driver from the ramdisk, to avoid needing to regenerate
-# the ramdisk on updates, and to ensure the power-management udev rules run
-# on module load
-omit_drivers+=" nvidia nvidia-drm nvidia-modeset nvidia-uvm "
-```
-
-and run `dracut -f` after creating it.
-
-## KEYBOARD BACKLIGHT MODES
-
-Models GA401, GA502, GU502 support LED brightness change only (no RGB).
-
-If you model isn't getting the correct led modes, you can edit the file
-`/etc/asusd/asusd-ledmodes.toml`, the LED Mode numbers are as follows:
-
-- Static
-- Breathe
-- Strobe
-- Rainbow
-- Star
-- Rain
-- Highlight
-- Laser
-- Ripple
-- Pulse
-- Comet
-- Flash
-
-use `cat /sys/class/dmi/id/product_name` to get details about your laptop. You
-must restart the `asusd.service` after editing.
-
-# Keybinds
-
-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
-```
-**Previous**
-```
-asusctl led-mode -p
-```
-
-To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profile -n`.
 
 # BUILDING
 
-Requirements are rust >= 1.40 installed from rustup.io if the distro provided version is too old, and `make`.
+Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
 
-**Ubuntu*:** `apt install libclang-dev libudev-dev`
+**Ubuntu (unsuported):**
 
-**fedora:** `dnf install clang-devel systemd-devel`
+    apt install libclang-dev libudev-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    make
+    sudo make install
+
+**fedora:**
+
+    dnf install cmake clang-devel systemd-devel gtk3-devel cargo
+    make
+    sudo make install
+
+**openSUSE:**
+
+Works with KDE Plasma (without GTK packages)
+
+    zypper in -t pattern devel_basis
+    zypper in rustup cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf-devel gtk3-devel
+    make
+    sudo make install
 
 ## Installing
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
+- Ubuntu = not supported due to packaging woes, but you can build and install on your own.
 
-Packaging and auto-builds are available [here](https://build.opensuse.org/package/show/home:luke_nukem:asus/asus-nb-ctrl)
+=======
-
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/)
-
----
-
-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.
@@ -179,70 +112,26 @@ $ systemctl daemon-reload && systemctl restart asusd
 
 You may also need to activate the service for debian install. If running Pop!_OS, I suggest disabling `system76-power` gnome-shell extension and systemd service.
 
-If you would like to run this daemon on another non-ASUS laptop you can. You'll
-have all features available except the LED and AniMe control (further controllers
-can be added on request). You will need to install the alternative service from
-`data/asusd-alt.service`.
-
 ## Uninstalling
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
-# USAGE
-
-Commands are given by:
-
-```
-asusctl <option> <command> <command-options>
-```
-
-Help is available through:
-
-```
-asusctl --help
-asusctl <command> --help
-```
-
-Some commands may have subcommands:
-
-```
-asusctl <command> <subcommand> --help
-```
-
-## 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
-```
-
 # OTHER
 
-## AniMe input
-
-You will want to look at what MeuMeu has done with [https://github.com/Meumeu/ZephyrusBling/](https://github.com/Meumeu/ZephyrusBling/)
-
 ## Supporting more laptops
 
 Please file a support request.
 
-## Notes:
+# License & Trademarks
-
-- If charge limit or fan modes are not working, then you may require a kernel newer than 5.6.10.
-- AniMe device check is performed on start, if your device has one it will be detected.
-- GA14/GA401 and GA15/GA502/GU502, You will need kernel [patches](https://lab.retarded.farm/zappel/asus-rog-zephyrus-g14/-/tree/master/kernel_patches), these are on their way to the kernel upstream.
-- On fedora manually installed Nvidia driver requires a dracut config as follows:
-```
-# filename/etc/dracut.conf.d/90-nvidia-dracut-G05.conf
-# Omit the nvidia driver from the ramdisk, to avoid needing to regenerate
-# the ramdisk on updates, and to ensure the power-management udev rules run
-# on module load
-omit_drivers+=" nvidia nvidia-drm nvidia-modeset nvidia-uvm "
-```
-
-# License
 
 Mozilla Public License 2 (MPL-2.0)
+
+---
+
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
+
+---

asus-notify/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "asus-notify"
-version = "3.0.0"
-authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-# serialisation
-serde_json = "^1.0"
-rog_dbus = { path = "../rog-dbus" }
-rog_types = { path = "../rog-types" }
-daemon = { path = "../daemon" }
-
-[dependencies.notify-rust]
-version = "^4.3"
-default-features = false
-features = ["z"]

asus-notify/src/main.rs

@@ -1,124 +0,0 @@
-use notify_rust::{Hint, Notification, NotificationHandle};
-use rog_dbus::{DbusProxies, Signals};
-use rog_types::profile::Profile;
-use std::error::Error;
-use std::thread::sleep;
-use std::time::Duration;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
-    println!("     daemon version {}", daemon::VERSION);
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
-
-    let (proxies, conn) = DbusProxies::new()?;
-    let signals = Signals::new(&proxies)?;
-
-    let mut last_profile_notif: Option<NotificationHandle> = None;
-    let mut last_led_notif: Option<NotificationHandle> = None;
-    let mut last_gfx_notif: Option<NotificationHandle> = None;
-    let mut last_chrg_notif: 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(mut lock) = signals.gfx_vendor.lock() {
-            if let Some(vendor) = lock.take() {
-                if let Some(notif) = last_gfx_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!(
-                    "Graphics mode changed to {}",
-                    <&str>::from(vendor)
-                ))?;
-                last_gfx_notif = Some(x);
-            }
-        }
-
-        if let Ok(mut lock) = signals.charge.lock() {
-            if let Some(limit) = lock.take() {
-                if let Some(notif) = last_chrg_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!("Battery charge limit changed to {}", limit))?;
-                last_chrg_notif = Some(x);
-            }
-        }
-
-        if let Ok(mut lock) = signals.profile.lock() {
-            if let Some(profile) = lock.take() {
-                if let Some(notif) = last_profile_notif.take() {
-                    notif.close();
-                }
-                if let Ok(profile) = serde_json::from_str(&profile) {
-                    let profile: Profile = profile;
-                    if let Ok(name) = proxies.profile().active_profile_name() {
-                        let x = do_thermal_notif(&profile, &name)?;
-                        last_profile_notif = Some(x);
-                    }
-                }
-            }
-        }
-
-        if let Ok(mut lock) = signals.led_mode.lock() {
-            if let Some(ledmode) = lock.take() {
-                if let Some(notif) = last_led_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!(
-                    "Keyboard LED mode changed to {}",
-                    ledmode.mode_name()
-                ))?;
-                last_led_notif = Some(x);
-            }
-        }
-    }
-}
-
-fn do_thermal_notif(profile: &Profile, label: &str) -> Result<NotificationHandle, Box<dyn Error>> {
-    let fan = profile.fan_preset;
-    let turbo = if profile.turbo { "enabled" } else { "disabled" };
-    let icon = match fan {
-        0 => "asus_notif_yellow",
-        1 => "asus_notif_red",
-        2 => "asus_notif_green",
-        _ => "asus_notif_red",
-    };
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!(
-            "Thermal profile changed to {}, turbo {}",
-            label.to_uppercase(),
-            turbo
-        ))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
-}
-
-fn do_notif(body: &str) -> Result<NotificationHandle, Box<dyn Error>> {
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(body)
-        .timeout(2000)
-        .show()?;
-    Ok(x)
-}

asusctl/Cargo.toml

@@ -1,23 +1,24 @@
 [package]
 name = "asusctl"
-version = "3.4.0"
+license = "MPL-2.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
+edition = "2021"
-
+version.workspace = true
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-# serialisation
-serde_json = "^1.0"
 rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
-rog_types = { path = "../rog-types" }
+rog_profiles = { path = "../rog-profiles" }
+rog_platform = { path = "../rog-platform" }
 daemon = { path = "../daemon" }
-gumdrop = "^0.8"
+
-yansi-term = "^0.1"
+gumdrop.workspace = true
+toml.workspace = true
+sysfs-class.workspace = true
 
 [dev-dependencies]
-tinybmp = "^0.2.3"
+gif.workspace = true
-glam = "0.14.0"
+tinybmp.workspace = true
+glam.workspace = true
 rog_dbus = { path = "../rog-dbus" }
-gif = "^0.11.2"

asusctl/examples/animatrix-diag-png.rs

@@ -1,26 +0,0 @@
-use std::{env, error::Error, path::Path, process::exit};
-
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::AuraDbusClient;
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = AuraDbusClient::new().unwrap();
-
-    let args: Vec<String> = env::args().into_iter().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())?;
-
-    client
-        .proxies()
-        .anime()
-        .write(<AnimeDataBuffer>::from(&matrix))
-        .unwrap();
-
-    Ok(())
-}

asusctl/examples/animatrix-outline.rs

@@ -1,129 +0,0 @@
-use rog_anime::AnimeDataBuffer;
-use rog_dbus::AuraDbusClient;
-
-// In usable data:
-// Top row start at 1, ends at 32
-
-fn main() {
-    let (client, _) = AuraDbusClient::new().unwrap();
-    let mut matrix = AnimeDataBuffer::new();
-    matrix.get_mut()[1] = 100; // start = 1
-    for n in matrix.get_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() {
-        *n = 250;
-    }
-    matrix.get_mut()[1244] = 100; // end
-    println!("{:?}", &matrix);
-
-    client.proxies().anime().write(matrix).unwrap();
-}

asusctl/examples/anime-diag-png.rs

@@ -0,0 +1,32 @@
+use std::{env, error::Error, path::Path, process::exit};
+
+use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+
+    let args: Vec<String> = env::args().into_iter().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(),
+        AnimeType::GA401,
+    )?;
+
+    let anime_type = get_anime_type()?;
+
+    client
+        .proxies()
+        .anime()
+        .write(matrix.into_data_buffer(anime_type)?)
+        .unwrap();
+
+    Ok(())
+}

asusctl/examples/anime-diag.rs

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

asusctl/examples/anime-gif.rs

@@ -1,10 +1,10 @@
 use std::{env, path::Path, thread::sleep};
 
-use rog_anime::{ActionData, AnimeAction, Sequences};
+use rog_anime::{usb::get_anime_type, ActionData, ActionLoader, Sequences};
-use rog_dbus::AuraDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() {
-    let (client, _) = AuraDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {
@@ -14,10 +14,11 @@ 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().unwrap();
+    let mut seq = Sequences::new(anime_type);
     seq.insert(
         0,
-        &AnimeAction::AsusAnimation {
+        &ActionLoader::AsusAnimation {
             file: path.into(),
             time: rog_anime::AnimTime::Infinite,
             brightness,

asusctl/examples/anime-grid.rs

@@ -1,5 +1,6 @@
-use rog_anime::{AnimeDataBuffer, AnimeGrid};
+use rog_anime::{usb::get_anime_type, AnimeDataBuffer, AnimeGrid};
-use rog_dbus::AuraDbusClient;
+use rog_dbus::RogDbusClientBlocking;
+use std::convert::TryFrom;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -7,15 +8,15 @@ use rog_dbus::AuraDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = AuraDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
-    let mut matrix = AnimeGrid::new(None);
+    let anime_type = get_anime_type().unwrap();
+    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 +39,7 @@ fn main() {
         }
     }
 
-    let matrix = <AnimeDataBuffer>::from(matrix);
+    let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
 
     client.proxies().anime().write(matrix).unwrap();
 }

asusctl/examples/anime-outline.rs

@@ -0,0 +1,130 @@
+use rog_anime::{usb::get_anime_type, AnimeDataBuffer};
+use rog_dbus::RogDbusClientBlocking;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+fn main() {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let anime_type = get_anime_type().unwrap();
+    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.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.data_mut()[1244] = 100; // end
+    println!("{:?}", &matrix);
+
+    client.proxies().anime().write(matrix).unwrap();
+}

asusctl/examples/anime-png.rs

@@ -1,12 +1,14 @@
+use std::convert::TryFrom;
 use std::{env, error::Error, path::Path, process::exit};
 
 use rog_anime::{
+    usb::get_anime_type,
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::AuraDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = AuraDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -15,6 +17,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
+    let anime_type = get_anime_type()?;
     let matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -24,12 +27,13 @@ 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))
+        .write(<AnimeDataBuffer>::try_from(&matrix)?)
         .unwrap();
 
     Ok(())

asusctl/examples/anime-spinning.rs

@@ -1,14 +1,16 @@
+use std::convert::TryFrom;
 use std::{
     env, error::Error, f32::consts::PI, path::Path, process::exit, thread::sleep, time::Duration,
 };
 
 use rog_anime::{
+    usb::get_anime_type,
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::AuraDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = AuraDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -17,6 +19,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
+    let anime_type = get_anime_type()?;
     let mut matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -26,19 +29,20 @@ 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))
+            .write(<AnimeDataBuffer>::try_from(&matrix)?)
             .unwrap();
         sleep(Duration::from_micros(500));
     }

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().per_key_raw(colours.get())?;
+
+        std::thread::sleep(std::time::Duration::from_millis(150));
+    }
+}

asusctl/examples/aura-rgb-breathe.rs

@@ -0,0 +1,59 @@
+//! Using a combination of key-colour array plus a key layout to generate outputs.
+
+use rog_aura::{keys::Key, layouts::KeyLayout, Breathe, Colour, Effect, LedType, Sequences, Speed};
+use rog_dbus::RogDbusClientBlocking;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let layout = KeyLayout::gx502_layout();
+
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+
+    let mut seq = Sequences::new();
+    let mut key = Effect::Breathe(Breathe::new(
+        LedType::Key(Key::W),
+        Colour(255, 127, 0),
+        Colour(127, 0, 255),
+        Speed::Med,
+    ));
+
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::A));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::S));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::D));
+    seq.push(key.clone());
+
+    let mut key = Effect::Breathe(Breathe::new(
+        LedType::Key(Key::Q),
+        Colour(127, 127, 127),
+        Colour(127, 255, 255),
+        Speed::Low,
+    ));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::E));
+    seq.push(key.clone());
+
+    let mut key = Effect::Breathe(Breathe::new(
+        LedType::Key(Key::N1),
+        Colour(166, 127, 166),
+        Colour(127, 155, 20),
+        Speed::High,
+    ));
+    key.set_led_type(LedType::Key(Key::Tilde));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::N2));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::N3));
+    seq.push(key.clone());
+    key.set_led_type(LedType::Key(Key::N4));
+    seq.push(key.clone());
+
+    loop {
+        seq.next_state(&layout);
+        let packets = seq.create_packets();
+
+        client.proxies().led().per_key_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(60));
+    }
+}

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

@@ -0,0 +1,34 @@
+//! Using a combination of key-colour array plus a key layout to generate outputs.
+
+use rog_aura::{layouts::KeyLayout, KeyColourArray};
+use rog_dbus::RogDbusClientBlocking;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let layout = KeyLayout::gx502_layout();
+    loop {
+        let mut key_colours = KeyColourArray::new();
+        for row in layout.rows() {
+            for (k, key) in row.row().enumerate() {
+                if k != 0 {
+                    if let Some(prev) = row.row().nth(k - 1) {
+                        if let Some(c) = key_colours.rgb_for_key(*prev) {
+                            c[0] = 0;
+                        };
+                    }
+                }
+
+                if key.is_placeholder() {
+                    continue;
+                }
+
+                if let Some(c) = key_colours.rgb_for_key(*key) {
+                    c[0] = 255;
+                };
+
+                client.proxies().led().per_key_raw(key_colours.get())?;
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
+        }
+    }
+}

asusctl/examples/aura-zoned-breathe.rs

@@ -0,0 +1,44 @@
+//! Using a combination of key-colour array plus a key layout to generate outputs.
+
+use rog_aura::{layouts::KeyLayout, Breathe, Colour, Effect, LedType, PerZone, Sequences, Speed};
+use rog_dbus::RogDbusClientBlocking;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let layout = KeyLayout::gx502_layout();
+
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+
+    let mut seq = Sequences::new();
+
+    let zone = Effect::Breathe(Breathe::new(
+        LedType::Zone(PerZone::KeyboardLeft),
+        Colour(166, 127, 166),
+        Colour(127, 155, 20),
+        Speed::High,
+    ));
+    seq.push(zone);
+
+    let zone = Effect::Breathe(Breathe::new(
+        LedType::Zone(PerZone::KeyboardCenterLeft),
+        Colour(16, 127, 255),
+        Colour(127, 15, 20),
+        Speed::Low,
+    ));
+    seq.push(zone);
+
+    let zone = Effect::Breathe(Breathe::new(
+        LedType::Zone(PerZone::LightbarRightCorner),
+        Colour(0, 255, 255),
+        Colour(255, 0, 255),
+        Speed::Med,
+    ));
+    seq.push(zone);
+
+    loop {
+        seq.next_state(&layout);
+        let packets = seq.create_packets();
+
+        client.proxies().led().per_key_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(60));
+    }
+}

asusctl/src/anime_cli.rs

@@ -1,54 +1,4 @@
 use gumdrop::Options;
-use rog_types::error::AuraError;
-use std::str::FromStr;
-
-#[derive(Copy, Clone, Debug)]
-pub enum AnimeStatusValue {
-    On,
-    Off,
-}
-impl FromStr for AnimeStatusValue {
-    type Err = AuraError;
-
-    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(AuraError::ParseAnime)
-            }
-        }
-    }
-}
-impl From<AnimeStatusValue> for bool {
-    fn from(value: AnimeStatusValue) -> Self {
-        match value {
-            AnimeStatusValue::On => true,
-            AnimeStatusValue::Off => false,
-        }
-    }
-}
-
-#[derive(Options)]
-pub struct AnimeLeds {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        required,
-        short = "b",
-        meta = "",
-        help = "set all leds brightness value"
-    )]
-    led_brightness: u8,
-}
-impl AnimeLeds {
-    pub fn led_brightness(&self) -> u8 {
-        self.led_brightness
-    }
-}
 
 #[derive(Options)]
 pub struct AnimeCommand {
@@ -56,21 +6,32 @@ pub struct AnimeCommand {
     pub help: bool,
     #[options(
         meta = "",
-        help = "turn on/off the panel (accept/reject write requests)"
+        help = "enable/disable the panel LEDs (does not erase last image)"
     )]
-    pub turn: Option<AnimeStatusValue>,
+    pub enable: Option<bool>,
-    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
+    #[options(
-    pub boot: Option<AnimeStatusValue>,
+        meta = "",
+        help = "enable/disable system animations (boot/sleep/shutdown)"
+    )]
+    pub boot_enable: Option<bool>,
+    #[options(meta = "", help = "set global AniMe brightness value")]
+    pub brightness: Option<f32>,
+    #[options(help = "clear the display")]
+    pub clear: bool,
     #[options(command)]
     pub command: Option<AnimeActions>,
 }
 
 #[derive(Options)]
 pub enum AnimeActions {
-    #[options(help = "change all leds brightness")]
+    #[options(help = "display a PNG image")]
-    Leds(AnimeLeds),
-    #[options(help = "display an 8bit greyscale png")]
     Image(AnimeImage),
+    #[options(help = "display a diagonal/pixel-perfect PNG")]
+    PixelImage(AnimeImageDiagonal),
+    #[options(help = "display an animated GIF")]
+    Gif(AnimeGif),
+    #[options(help = "display an animated diagonal/pixel-perfect GIF")]
+    PixelGif(AnimeGifDiagonal),
 }
 
 #[derive(Options)]
@@ -90,3 +51,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,10 +1,72 @@
 use gumdrop::Options;
-use rog_types::{
+use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
-    aura_modes::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed},
-    error::AuraError,
-};
 use std::str::FromStr;
 
+#[derive(Options)]
+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(meta = "", help = "Use with awake option <true/false>")]
+    pub keyboard: Option<bool>,
+    #[options(meta = "", help = "Use with awake option <true/false>")]
+    pub lightbar: Option<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)]
+pub struct LedPowerCommand2 {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(command)]
+    pub command: Option<SetAuraEnabled>,
+}
+
+#[derive(Options)]
+pub enum SetAuraEnabled {
+    /// Applies to both old and new models
+    #[options(help = "set <keyboard, logo, lightbar> to enabled while device is awake")]
+    Awake(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to enabled while the device is booting")]
+    Boot(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is suspended")]
+    Sleep(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is shutdown")]
+    Shutdown(AuraEnabled),
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct AuraEnabled {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "<true/false>")]
+    pub keyboard: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub logo: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub lightbar: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub lid: Option<bool>,
+}
+
+// impl FromStr for AuraEnabled {
+//     type Err = Error;
+
+//     fn from_str(s: &str) -> Result<Self, Self::Err> {
+//         let s = s.to_lowercase();
+//         Ok(Self {
+//             help: false,
+//             keyboard: None,
+//             logo: None,
+//             lightbar: None,
+//         })
+//     }
+// }
+
 #[derive(Options)]
 pub struct LedBrightness {
     level: Option<u32>,
@@ -19,7 +81,7 @@ impl LedBrightness {
     }
 }
 impl FromStr for LedBrightness {
-    type Err = AuraError;
+    type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let s = s.to_lowercase();
@@ -30,7 +92,7 @@ impl FromStr for LedBrightness {
             "high" => Ok(LedBrightness { level: Some(0x03) }),
             _ => {
                 print!("Invalid argument, must be one of: off, low, med, high");
-                Err(AuraError::ParseBrightness)
+                Err(Error::ParseBrightness)
             }
         }
     }
@@ -43,7 +105,7 @@ impl ToString for LedBrightness {
             Some(0x02) => "high",
             _ => "unknown",
         };
-        s.to_string()
+        s.to_owned()
     }
 }
 
@@ -53,7 +115,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")]
@@ -62,6 +131,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)]
@@ -70,6 +145,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)]
@@ -80,6 +161,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)]
@@ -92,10 +179,16 @@ 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 {
+pub struct MultiZone {
     #[options(help = "print help message")]
     help: bool,
     #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
@@ -127,6 +220,8 @@ pub struct MultiColourSpeed {
 /// Byte value for setting the built-in mode.
 ///
 /// Enum corresponds to the required integer value
+///
+// NOTE: The option names here must match those in rog-aura crate
 #[derive(Options)]
 pub enum SetAuraBuiltin {
     #[options(help = "set a single static colour")]
@@ -138,7 +233,7 @@ pub enum SetAuraBuiltin {
     #[options(help = "rainbow cycling in one of four directions")]
     Rainbow(SingleSpeedDirection),
     #[options(help = "rain pattern mimicking raindrops")]
-    Star(TwoColourSpeed),
+    Stars(TwoColourSpeed),
     #[options(help = "rain pattern of three preset colours")]
     Rain(SingleSpeed),
     #[options(help = "pressed keys are highlighted to fade")]
@@ -153,10 +248,6 @@ pub enum SetAuraBuiltin {
     Comet(SingleColour),
     #[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),
 }
 
 impl Default for SetAuraBuiltin {
@@ -169,6 +260,7 @@ impl From<&SingleColour> for AuraEffect {
     fn from(aura: &SingleColour) -> Self {
         Self {
             colour1: aura.colour,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -178,6 +270,7 @@ impl From<&SingleSpeed> for AuraEffect {
     fn from(aura: &SingleSpeed) -> Self {
         Self {
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -188,6 +281,7 @@ impl From<&SingleColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -198,6 +292,7 @@ impl From<&TwoColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             colour2: aura.colour2,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -208,6 +303,7 @@ impl From<&SingleSpeedDirection> for AuraEffect {
         Self {
             speed: aura.speed,
             direction: aura.direction,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -236,7 +332,7 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Rainbow;
                 data
             }
-            SetAuraBuiltin::Star(x) => {
+            SetAuraBuiltin::Stars(x) => {
                 let mut data: AuraEffect = x.into();
                 data.mode = AuraModeNum::Star;
                 data
@@ -276,55 +372,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

@@ -0,0 +1,97 @@
+use crate::{
+    anime_cli::AnimeCommand,
+    aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin},
+    profiles_cli::{FanCurveCommand, ProfileCommand},
+};
+use gumdrop::Options;
+
+#[derive(Default, Options)]
+pub struct CliStart {
+    #[options(help_flag, help = "print help message")]
+    pub help: bool,
+    #[options(help = "show program version number")]
+    pub version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    pub show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    pub kbd_bright: Option<LedBrightness>,
+    #[options(help = "Toggle to next keyboard brightness")]
+    pub next_kbd_bright: bool,
+    #[options(help = "Toggle to previous keyboard brightness")]
+    pub prev_kbd_bright: bool,
+    #[options(meta = "", help = "Set your battery charge limit <20-100>")]
+    pub chg_limit: Option<u8>,
+    #[options(command)]
+    pub command: Option<CliCommand>,
+}
+
+#[derive(Options)]
+pub enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedMode(LedModeCommand),
+    #[options(help = "Set the LED power states")]
+    LedPow1(LedPowerCommand1),
+    #[options(help = "Set the LED power states")]
+    LedPow2(LedPowerCommand2),
+    #[options(help = "Set or select platform_profile")]
+    Profile(ProfileCommand),
+    #[options(help = "Set, select, or modify fan curves if supported")]
+    FanCurve(FanCurveCommand),
+    #[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
+    Anime(AnimeCommand),
+    #[options(help = "Change bios settings")]
+    Bios(BiosCommand),
+}
+
+#[derive(Options)]
+pub struct LedModeCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "switch to next aura mode")]
+    pub next_mode: bool,
+    #[options(help = "switch to previous aura mode")]
+    pub prev_mode: bool,
+    #[options(command)]
+    pub command: Option<SetAuraBuiltin>,
+}
+
+#[derive(Options)]
+pub struct GraphicsCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+}
+
+#[derive(Options, Debug)]
+pub struct BiosCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        short = "S",
+        no_long,
+        help = "set bios POST sound: asusctl -p <true/false>"
+    )]
+    pub post_sound_set: Option<bool>,
+    #[options(no_long, short = "s", help = "read bios POST sound")]
+    pub post_sound_get: bool,
+    #[options(
+        meta = "",
+        short = "D",
+        no_long,
+        help = "Switch GPU MUX mode: 0 = Discrete, 1 = Optimus, reboot required"
+    )]
+    pub gpu_mux_mode_set: Option<u8>,
+    #[options(no_long, short = "d", help = "get GPU mode")]
+    pub gpu_mux_mode_get: bool,
+    #[options(
+        meta = "",
+        short = "O",
+        no_long,
+        help = "Set device panel overdrive <true/false>"
+    )]
+    pub panel_overdrive_set: Option<bool>,
+    #[options(no_long, short = "o", help = "get panel overdrive")]
+    pub panel_overdrive_get: bool,
+}

asusctl/src/profiles_cli.rs

@@ -0,0 +1,51 @@
+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>,
+}

daemon-user/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "daemon-user"
-version = "1.0.0"
+license = "MPL-2.0"
+version.workspace = true
 authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
+edition = "2021"
 description = "Usermode daemon for user settings, anime, per-key lighting"
 
 [lib]
@@ -14,17 +15,17 @@ name = "asusd-user"
 path = "src/daemon.rs"
 
 [dependencies]
+dirs.workspace = true
+smol.workspace = true
+
 # serialisation
-serde = "^1.0"
+serde.workspace = true
-serde_json = "^1.0"
+serde_json.workspace = true
-serde_derive = "^1.0"
+serde_derive.workspace = true
 
 rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
-rog_types = { path = "../rog-types" }
+rog_platform = { path = "../rog-platform" }
 
-dirs = "3.0.1"
+zbus.workspace = true
-
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"

daemon-user/src/ctrl_anime.rs

@@ -1,6 +1,6 @@
-use rog_anime::{ActionData, AnimTime, AnimeAction, Sequences, Vec2};
+use rog_anime::error::AnimeError;
-use rog_dbus::AuraDbusClient;
+use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
-//use crate::dbus::DbusEvents;
+use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
 use std::time::Duration;
 use std::{
@@ -11,11 +11,51 @@ use std::{
     },
 };
 use std::{sync::Arc, thread::sleep, time::Instant};
-use zbus::dbus_interface;
+use zbus::{
-use zvariant::ObjectPath;
+    dbus_interface,
-use zvariant_derive::Type;
+    zvariant::{ObjectPath, Type},
+};
 
-use crate::{error::Error, user_config::UserConfig};
+use crate::user_config::ConfigLoadSave;
+use crate::{error::Error, user_config::UserAnimeConfig};
+
+#[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
+    count: u64,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
+    fade_in: Option<u64>,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image out for
+    fade_out: Option<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);
+                    let show_for = if time.count != 0 {
+                        Some(Duration::from_millis(time.count))
+                    } else {
+                        None
+                    };
+                    AnimTime::Fade(Fade::new(fade_in, show_for, fade_out))
+                } else {
+                    AnimTime::Time(Duration::from_millis(time.count))
+                }
+            }
+            TimeType::Count => AnimTime::Count(time.count as u32),
+            TimeType::Infinite => AnimTime::Infinite,
+        }
+    }
+}
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
 pub enum TimeType {
@@ -28,15 +68,15 @@ pub enum TimeType {
 /// and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: AuraDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
-    do_early_return: &'a AtomicBool,
+    do_early_return: Arc<AtomicBool>,
 }
 
 impl<'a> CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: AuraDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
-        do_early_return: &'static AtomicBool,
+        do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
             sequences,
@@ -45,7 +85,7 @@ impl<'a> CtrlAnimeInner<'static> {
         })
     }
     /// To be called on each main loop iteration to pump out commands to the anime
-    pub fn run(&self) -> Result<(), Error> {
+    pub fn run(&'a self) -> Result<(), Error> {
         if self.do_early_return.load(Ordering::SeqCst) {
             return Ok(());
         }
@@ -53,39 +93,24 @@ impl<'a> CtrlAnimeInner<'static> {
         for action in self.sequences.iter() {
             match action {
                 ActionData::Animation(frames) => {
-                    let mut count = 0;
+                    rog_anime::run_animation(frames, &|output| {
-                    let start = Instant::now();
+                        if self.do_early_return.load(Ordering::Acquire) {
-                    'animation: loop {
+                            return Ok(true); // Do safe exit
-                        for frame in frames.frames() {
-                            if self.do_early_return.load(Ordering::SeqCst) {
-                                return Ok(());
-                            }
-                            self.client
-                                .proxies()
-                                .anime()
-                                .write(frame.frame().clone())
-                                .unwrap();
-                            if let AnimTime::Time(time) = frames.duration() {
-                                if Instant::now().duration_since(start) > time {
-                                    break 'animation;
-                                }
-                            }
-                            sleep(frame.delay());
                         }
-                        if let AnimTime::Cycles(times) = frames.duration() {
+                        self.client
-                            count += 1;
+                            .proxies()
-                            if count >= times {
+                            .anime()
-                                break 'animation;
+                            .write(output)
-                            }
+                            .map_err(|e| AnimeError::Dbus(format!("{}", e)))
-                        }
+                            .map(|_| false)
-                    }
+                    });
                 }
                 ActionData::Image(image) => {
                     self.client
                         .proxies()
                         .anime()
                         .write(image.as_ref().clone())
-                        .unwrap();
+                        .ok();
                 }
                 ActionData::Pause(duration) => {
                     let start = Instant::now();
@@ -99,10 +124,10 @@ impl<'a> CtrlAnimeInner<'static> {
                         sleep(Duration::from_millis(1));
                     }
                 }
-                ActionData::AudioEq => {}
+                ActionData::AudioEq
-                ActionData::SystemInfo => {}
+                | ActionData::SystemInfo
-                ActionData::TimeDate => {}
+                | ActionData::TimeDate
-                ActionData::Matrix => {}
+                | ActionData::Matrix => {}
             }
         }
 
@@ -111,34 +136,36 @@ impl<'a> CtrlAnimeInner<'static> {
 }
 
 pub struct CtrlAnime<'a> {
-    config: Arc<Mutex<UserConfig>>,
+    config: Arc<Mutex<UserAnimeConfig>>,
-    client: AuraDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
-    inner_early_return: &'a AtomicBool,
+    inner_early_return: Arc<AtomicBool>,
 }
 
-impl<'a> CtrlAnime<'static> {
+impl CtrlAnime<'static> {
     pub fn new(
-        config: Arc<Mutex<UserConfig>>,
+        config: Arc<Mutex<UserAnimeConfig>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: AuraDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
-        inner_early_return: &'static AtomicBool,
+        inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
             config,
-            inner,
             client,
+            inner,
             inner_early_return,
         })
     }
 
-    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+    pub async fn add_to_server(self, server: &mut zbus::Connection) {
         server
+            .object_server()
             .at(
                 &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
                 self,
             )
+            .await
             .map_err(|err| {
                 println!("CtrlAnime: add_to_server {}", err);
                 err
@@ -147,7 +174,6 @@ impl<'a> CtrlAnime<'static> {
     }
 }
 
-
 // The pattern for a zbus method is:
 // - Get config lock if required
 // - Set inner_early_return to stop the inner run loop temporarily
@@ -159,19 +185,14 @@ impl CtrlAnime<'static> {
     pub fn insert_asus_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
-        time: TimeType,
+        time: Timer,
-        count: u32,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
         if let Ok(mut config) = self.config.try_lock() {
-            let time: AnimTime = match time {
+            let time: AnimTime = time.into();
-                TimeType::Timer => AnimTime::Time(Duration::from_millis(count as u64)),
-                TimeType::Count => AnimTime::Cycles(count),
-                TimeType::Infinite => AnimTime::Infinite,
-            };
             let file = Path::new(&file);
-            let action = AnimeAction::AsusAnimation {
+            let action = ActionLoader::AsusAnimation {
                 file: file.into(),
                 brightness,
                 time,
@@ -181,7 +202,10 @@ impl CtrlAnime<'static> {
             self.inner_early_return.store(true, Ordering::SeqCst);
 
             if let Ok(mut controller) = self.inner.lock() {
-                controller.sequences.insert(index as usize, &action)?;
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
             config.write()?;
@@ -199,23 +223,18 @@ impl CtrlAnime<'static> {
     pub fn insert_image_gif(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
-        time: TimeType,
+        time: Timer,
-        count: u32,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
         if let Ok(mut config) = self.config.try_lock() {
-            let time: AnimTime = match time {
+            let time: AnimTime = time.into();
-                TimeType::Timer => AnimTime::Time(Duration::from_millis(count as u64)),
-                TimeType::Count => AnimTime::Cycles(count),
-                TimeType::Infinite => AnimTime::Infinite,
-            };
             let file = Path::new(&file);
             let translation = Vec2::new(xy.0, xy.1);
-            let action = AnimeAction::ImageAnimation {
+            let action = ActionLoader::ImageAnimation {
                 file: file.into(),
                 scale,
                 angle,
@@ -228,7 +247,10 @@ impl CtrlAnime<'static> {
             self.inner_early_return.store(true, Ordering::SeqCst);
 
             if let Ok(mut controller) = self.inner.lock() {
-                controller.sequences.insert(index as usize, &action)?;
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
             config.write()?;
@@ -243,30 +265,37 @@ impl CtrlAnime<'static> {
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn insert_image(
         &mut self,
         index: u32,
-        file: String,
+        file: &str,
         scale: f32,
         angle: f32,
         xy: (f32, f32),
+        time: Timer,
         brightness: f32,
     ) -> zbus::fdo::Result<String> {
         if let Ok(mut config) = self.config.try_lock() {
             let file = Path::new(&file);
-            let action = AnimeAction::Image {
+            let time = time.into();
+            let action = ActionLoader::Image {
                 file: file.into(),
                 scale,
                 angle,
                 translation: Vec2::new(xy.0, xy.1),
                 brightness,
+                time,
             };
 
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
 
             if let Ok(mut controller) = self.inner.lock() {
-                controller.sequences.insert(index as usize, &action)?;
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
             config.write()?;
@@ -283,12 +312,15 @@ impl CtrlAnime<'static> {
 
     pub fn insert_pause(&mut self, index: u32, millis: u64) -> zbus::fdo::Result<String> {
         if let Ok(mut config) = self.config.try_lock() {
-            let action = AnimeAction::Pause(Duration::from_millis(millis));
+            let action = ActionLoader::Pause(Duration::from_millis(millis));
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
 
             if let Ok(mut controller) = self.inner.lock() {
-                controller.sequences.insert(index as usize, &action)?;
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
             config.write()?;
@@ -329,13 +361,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().toggle_on(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().toggle_on(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
         }
         Ok(())
     }

daemon-user/src/daemon.rs

@@ -1,67 +1,113 @@
-use rog_dbus::AuraDbusClient;
+use rog_anime::usb::get_anime_type;
-use rog_types::supported::SupportedFunctions;
+use rog_aura::layouts::KeyLayout;
+use rog_dbus::RogDbusClientBlocking;
 use rog_user::{
     ctrl_anime::{CtrlAnime, CtrlAnimeInner},
     user_config::*,
     DBUS_NAME,
 };
-use std::sync::Arc;
+use smol::Executor;
 use std::sync::Mutex;
-use std::thread;
+use std::{fs::OpenOptions, io::Read, path::PathBuf, sync::Arc};
-use zbus::{fdo, Connection};
+use zbus::Connection;
 
 use std::sync::atomic::AtomicBool;
 
-/// The anime loop needs an atomic to make it exit early if required
+#[cfg(not(feature = "local_data"))]
-static ANIME_INNER_EARLY_RETURN: AtomicBool = AtomicBool::new(false);
+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>> {
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
+    println!("  user daemon v{}", rog_user::VERSION);
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
 
-    let (client, _) = AuraDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new()?;
-    let supported = client.proxies().supported().get_supported_functions()?;
+    let supported = client.proxies().supported().supported_functions()?;
-    let supported = serde_json::from_str::<SupportedFunctions>(&&supported).unwrap();
 
     let mut config = UserConfig::new();
-    config.load_config()?;
+    config.load()?;
-    let anime = config.create_anime()?;
 
-    let config = Arc::new(Mutex::new(config));
+    let executor = Executor::new();
-
-    // Create server
-    let connection = Connection::new_session()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut server = zbus::ObjectServer::new(&connection);
 
+    let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
     if supported.anime_ctrl.0 {
-        // Inner behind mutex required for thread safety
+        if let Some(cfg) = config.active_anime {
-        let inner = Arc::new(Mutex::new(CtrlAnimeInner::new(
+            let anime_type = get_anime_type()?;
-            anime,
+            let anime_config = UserAnimeConfig::load(cfg)?;
-            client,
+            let anime = anime_config.create(anime_type)?;
-            &ANIME_INNER_EARLY_RETURN,
+            let anime_config = Arc::new(Mutex::new(anime_config));
-        )?));
-        // Need new client object for dbus control part
-        let (client, _) = AuraDbusClient::new().unwrap();
-        let anime_control =
-            CtrlAnime::new(config, inner.clone(), client, &ANIME_INNER_EARLY_RETURN)?;
-        anime_control.add_to_server(&mut server);
-        // Thread using inner
-        let _anime_thread = thread::Builder::new()
-            .name("Anime User".into())
-            .spawn(move || loop {
-                if let Ok(inner) = inner.try_lock() {
-                    inner.run().unwrap();
-                }
-            })?;
-    }
 
-    if supported.keyboard_led.per_key_led_mode {}
+            executor
+                .spawn(async move {
+                    // Create server
+                    let mut connection = Connection::session().await.unwrap();
+                    connection.request_name(DBUS_NAME).await.unwrap();
 
-    loop {
+                    // Inner behind mutex required for thread safety
-        if let Err(err) = server.try_handle_next() {
+                    let inner = Arc::new(Mutex::new(
-            println!("{}", err);
+                        CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let (client, _) = RogDbusClientBlocking::new().unwrap();
+                    let anime_control =
+                        CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                    anime_control.add_to_server(&mut connection).await;
+                    loop {
+                        if let Ok(inner) = inner.clone().try_lock() {
+                            inner.run().ok();
+                        }
+                    }
+                })
+                .detach();
         }
     }
+
+    // if supported.keyboard_led.per_key_led_mode {
+    if let Some(cfg) = config.active_aura {
+        let mut aura_config = UserAuraConfig::load(cfg)?;
+
+        // Find and load a matching layout for laptop
+        let mut file = OpenOptions::new()
+            .read(true)
+            .open(PathBuf::from(BOARD_NAME))
+            .map_err(|e| {
+                println!("{BOARD_NAME}, {e}");
+                e
+            })?;
+        let mut board_name = String::new();
+        file.read_to_string(&mut board_name)?;
+
+        let layout = KeyLayout::find_layout(board_name.as_str(), PathBuf::from(DATA_DIR))
+            .map_err(|e| {
+                println!("{BOARD_NAME}, {e}");
+            })
+            .unwrap_or_else(|_| KeyLayout::ga401_layout());
+
+        executor
+            .spawn(async move {
+                // Create server
+                let (client, _) = RogDbusClientBlocking::new().unwrap();
+                // let connection = Connection::session().await.unwrap();
+                // connection.request_name(DBUS_NAME).await.unwrap();
+
+                loop {
+                    aura_config.aura.next_state(&layout);
+                    let packets = aura_config.aura.create_packets();
+
+                    client.proxies().led().per_key_raw(packets).unwrap();
+                    std::thread::sleep(std::time::Duration::from_millis(33));
+                }
+            })
+            .detach();
+    }
+    // }
+
+    loop {
+        smol::block_on(executor.tick());
+    }
 }

daemon-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"),

daemon-user/src/lib.rs

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

daemon-user/src/user_config.rs

@@ -4,56 +4,259 @@ use std::{
     time::Duration,
 };
 
-use rog_anime::{AnimTime, AnimeAction, Sequences, Vec2};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences, Vec2};
+use rog_aura::{keys::Key, Breathe, Colour, Effect, Flicker, LedType, Speed, Static};
+use serde::de::DeserializeOwned;
 use serde_derive::{Deserialize, Serialize};
 
 use crate::error::Error;
 
-#[derive(Debug, Default, Deserialize, Serialize)]
+pub trait ConfigLoadSave<T: DeserializeOwned + serde::Serialize> {
-pub struct UserConfig {
+    fn name(&self) -> String;
-    pub anime: Vec<AnimeAction>,
+
+    fn default_with_name(name: String) -> T;
+
+    fn write(&self) -> Result<(), Error>
+    where
+        Self: serde::Serialize,
+    {
+        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();
+        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(())
+    }
+
+    fn load(name: String) -> Result<T, 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 = Self::default_with_name(name);
+                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::<T>(&buf) {
+                return Ok(data);
+            }
+        }
+        Err(Error::ConfigLoadFail)
+    }
 }
 
-impl UserConfig {
+#[derive(Debug, Deserialize, Serialize)]
-    pub fn new() -> Self {
+pub struct UserAnimeConfig {
-        let x = Self {
+    pub name: String,
+    pub anime: Vec<ActionLoader>,
+}
+
+impl UserAnimeConfig {
+    pub fn create(&self, anime_type: AnimeType) -> Result<Sequences, Error> {
+        let mut seq = Sequences::new(anime_type);
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+}
+
+impl ConfigLoadSave<UserAnimeConfig> for UserAnimeConfig {
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn default_with_name(name: String) -> Self {
+        UserAnimeConfig {
+            name,
+            ..Default::default()
+        }
+    }
+}
+
+impl Default for UserAnimeConfig {
+    fn default() -> Self {
+        Self {
+            name: "default".to_owned(),
             anime: vec![
-                AnimeAction::AsusAnimation {
+                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::Cycles(1),
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(6),
+                        None,
+                        Duration::from_secs(3),
+                    )),
                 },
-                AnimeAction::ImageAnimation {
+                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::Time(Duration::from_secs(5)),
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
                 },
-                AnimeAction::Image {
+                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,
                 },
-                AnimeAction::Pause(Duration::from_secs(6)),
+                ActionLoader::Pause(Duration::from_secs(1)),
-                AnimeAction::ImageAnimation {
+                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::Cycles(2),
+                    time: AnimTime::Count(2),
                 },
             ],
-        };
+        }
-        println!("{}", serde_json::to_string_pretty(&x).unwrap());
+    }
-        x
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UserAuraConfig {
+    pub name: String,
+    pub aura: rog_aura::Sequences,
+}
+
+impl ConfigLoadSave<UserAuraConfig> for UserAuraConfig {
+    fn name(&self) -> String {
+        self.name.clone()
     }
 
-    pub fn load_config(&mut self) -> Result<(), Error> {
+    fn default_with_name(name: String) -> Self {
+        UserAuraConfig {
+            name,
+            ..Default::default()
+        }
+    }
+}
+
+impl Default for UserAuraConfig {
+    fn default() -> Self {
+        let mut seq = rog_aura::Sequences::new();
+        let mut key = Effect::Breathe(Breathe::new(
+            LedType::Key(Key::W),
+            Colour(255, 0, 20),
+            Colour(20, 255, 0),
+            Speed::Low,
+        ));
+
+        seq.push(key.clone());
+        key.set_led_type(LedType::Key(Key::A));
+        seq.push(key.clone());
+        key.set_led_type(LedType::Key(Key::S));
+        seq.push(key.clone());
+        key.set_led_type(LedType::Key(Key::D));
+        seq.push(key);
+
+        let key = Effect::Breathe(Breathe::new(
+            LedType::Key(Key::F),
+            Colour(255, 0, 0),
+            Colour(255, 0, 0),
+            Speed::High,
+        ));
+        seq.push(key);
+
+        let mut key = Effect::Static(Static::new(LedType::Key(Key::RCtrl), Colour(0, 0, 255)));
+        seq.push(key.clone());
+        key.set_led_type(LedType::Key(Key::LCtrl));
+        seq.push(key.clone());
+        key.set_led_type(LedType::Key(Key::Esc));
+        seq.push(key);
+
+        let key = Effect::Flicker(Flicker::new(
+            LedType::Key(Key::N9),
+            Colour(0, 0, 255),
+            80,
+            40,
+        ));
+        seq.push(key);
+
+        Self {
+            name: "default".to_owned(),
+            aura: seq,
+        }
+    }
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct UserConfig {
+    /// 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 UserConfig {
+    pub fn new() -> Self {
+        Self {
+            active_anime: Some("anime-default".to_owned()),
+            active_aura: Some("aura-default".to_owned()),
+        }
+    }
+
+    pub fn load(&mut self) -> Result<(), Error> {
         let mut path = if let Some(dir) = dirs::config_dir() {
             dir
         } else {
@@ -80,7 +283,8 @@ impl UserConfig {
                 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.anime = data.anime;
+                self.active_anime = data.active_anime;
+                self.active_aura = data.active_aura;
                 return Ok(());
             }
         }
@@ -101,21 +305,14 @@ impl UserConfig {
 
         path.push("rog-user.cfg");
 
-        let mut file = OpenOptions::new().write(true).create(true).truncate(true).open(&path)?;
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(&path)?;
 
         let json = serde_json::to_string_pretty(&self).unwrap();
-        dbg!(&json);
         file.write_all(json.as_bytes())?;
         Ok(())
     }
-
-    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)
-    }
 }

daemon-user/src/zbus_anime.rs

@@ -18,6 +18,7 @@
 //! * [`zbus::fdo::PropertiesProxy`]
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+#![allow(clippy::too_many_arguments)]
 
 use zbus::dbus_proxy;
 

daemon/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "daemon"
-version = "3.4.0"
 license = "MPL-2.0"
+version.workspace = true
 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"
+edition = "2021"
 
 [lib]
 name = "daemon"
@@ -18,28 +18,29 @@ name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
-rog_anime = { path = "../rog-anime" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
-rog_types = { path = "../rog-types" }
+rog_aura = { path = "../rog-aura", features = ["dbus"] }
+rog_platform = { path = "../rog-platform" }
+rog_profiles = { path = "../rog-profiles" }
 rog_dbus = { path = "../rog-dbus" }
-rusb = "^0.8"
+
-udev = "^0.6"
+async-trait.workspace = true
+tokio.workspace = true
 
 # cli and logging
-log = "^0.4"
+log.workspace = true
-env_logger = "^0.8"
+env_logger.workspace = true
 
-zbus = "^1.9.1"
+zbus.workspace = true
-zvariant = "^2.6"
+logind-zbus.workspace = true
-logind-zbus = "^0.7.1"
 
 # serialisation
-serde = "^1.0"
+serde.workspace = true
-serde_derive = "^1.0"
+serde_derive.workspace = true
-serde_json = "^1.0"
+serde_json.workspace = true
-toml = "^0.5"
+toml.workspace = true
 
 # Device control
-sysfs-class = "^0.1.2" # used for backlight control and baord ID
+sysfs-class.workspace = true # used for backlight control and baord ID
-rog_fan_curve = { version = "0.1", features = ["serde"] }
+
-# cpu power management
+concat-idents.workspace = true
-intel-pstate = "^0.2"

daemon/src/config.rs

@@ -1,140 +1,84 @@
-use log::{error, info, warn};
+use log::{error, warn};
-use rog_types::{gfx_vendors::GfxVendors, profile::Profile};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
-
+use std::path::PathBuf;
-use crate::config_old::*;
-use crate::VERSION;
 
 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-pub static AURA_CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Default)]
 pub struct Config {
-    pub gfx_mode: GfxVendors,
+    /// Save charge limit for restoring on boot
-    pub gfx_managed: bool,
-    pub gfx_vfio_enable: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
     pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, Profile>,
+    pub panel_od: bool,
-}
+    pub ac_command: String,
-
+    pub bat_command: String,
-impl Default for Config {
-    fn default() -> Self {
-        let mut pwr = BTreeMap::new();
-        pwr.insert("normal".into(), Profile::new(0, 100, true, 0, None));
-        pwr.insert("boost".into(), Profile::new(0, 100, true, 1, None));
-        pwr.insert("silent".into(), Profile::new(0, 100, true, 2, None));
-
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: true,
-            gfx_vfio_enable: false,
-            active_profile: "normal".into(),
-            toggle_profiles: vec!["normal".into(), "boost".into(), "silent".into()],
-            curr_fan_mode: 0,
-            bat_charge_limit: 100,
-            power_profiles: pwr,
-        }
-    }
 }
 
 impl Config {
+    fn new() -> Self {
+        Config {
+            bat_charge_limit: 100,
+            panel_od: false,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+
     /// `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)
+            .open(&PathBuf::from(CONFIG_PATH))
-            .unwrap_or_else(|_| {
+            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    CONFIG_PATH
-                )
-            }); // okay to cause panic here
         let mut buf = String::new();
+        let config;
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
-                return Config::create_default(&mut file);
+                config = Self::new();
+            } else if let Ok(data) = serde_json::from_str(&buf) {
+                config = data;
+            } else if let Ok(data) = serde_json::from_str::<Config455>(&buf) {
+                config = data.into();
             } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
+                warn!(
-                    return data;
+                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                } else if let Ok(data) = serde_json::from_str::<ConfigV324>(&buf) {
+                    CONFIG_PATH, CONFIG_PATH
-                    let config = data.into_current();
+                );
-                    config.write();
+                let cfg_old = CONFIG_PATH.to_owned() + "-old";
-                    info!("Updated config version to: {}", VERSION);
+                std::fs::rename(CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    return config;
+                    panic!(
-                } else if let Ok(data) = serde_json::from_str::<ConfigV317>(&buf) {
+                        "Could not rename. Please remove {} then restart service: Error {}",
-                    let config = data.into_current();
+                        CONFIG_PATH, err
-                    config.write();
+                    )
-                    info!("Updated config version to: {}", VERSION);
+                });
-                    return config;
+                config = Self::new();
-                } else if let Ok(data) = serde_json::from_str::<ConfigV301>(&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::<ConfigV222>(&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::<ConfigV212>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    return config;
-                }
-                warn!("Could not deserialise {}", CONFIG_PATH);
-                panic!("Please remove {} then restart asusd", CONFIG_PATH);
             }
+        } else {
+            config = Self::new();
         }
-        Config::create_default(&mut file)
+        config.write();
-    }
-
-    fn create_default(file: &mut File) -> Self {
-        let config = Config::default();
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", CONFIG_PATH));
         config
     }
 
     pub fn read(&mut self) {
         let mut file = OpenOptions::new()
             .read(true)
-            .open(&CONFIG_PATH)
+            .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 {
-                let x: Config = serde_json::from_str(&buf)
+                *self = serde_json::from_str(&buf)
                     .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-                *self = x;
             }
         }
     }
 
-    pub fn read_new() -> Result<Config, Box<dyn std::error::Error>> {
-        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();
-        file.read_to_string(&mut buf)?;
-        let x: Config = serde_json::from_str(&buf)?;
-        Ok(x)
-    }
-
     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");
@@ -142,3 +86,22 @@ impl Config {
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
 }
+
+#[derive(Deserialize, Serialize, Default)]
+#[serde(default)]
+pub struct Config455 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+}
+
+impl From<Config455> for Config {
+    fn from(c: Config455) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+}

daemon/src/config_aura.rs

@@ -1,148 +0,0 @@
-use crate::laptops::LaptopLedData;
-use log::{error, info, warn};
-use rog_types::aura_modes::{AuraEffect, AuraModeNum, AuraMultiZone, 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,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AuraConfig {
-    pub brightness: LedBrightness,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl Default for AuraConfig {
-    fn default() -> Self {
-        AuraConfig {
-            brightness: LedBrightness::Med,
-            current_mode: AuraModeNum::Static,
-            builtins: BTreeMap::new(),
-            multizone: None,
-        }
-    }
-}
-
-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;
-                }
-                warn!("Could not deserialise {}", AURA_CONFIG_PATH);
-                panic!("Please remove {} then restart asusd", AURA_CONFIG_PATH);
-            }
-        }
-        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 accecpt 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
-    }
-}

daemon/src/config_old.rs

@@ -1,156 +0,0 @@
-use rog_types::{aura_modes::AuraEffect, gfx_vendors::GfxVendors, profile::Profile};
-use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-
-use crate::config::Config;
-
-/// for parsing old v2.1.2 config
-#[allow(dead_code)]
-#[derive(Deserialize)]
-pub(crate) struct ConfigV212 {
-    gfx_managed: bool,
-    bat_charge_limit: u8,
-    active_profile: String,
-    toggle_profiles: Vec<String>,
-    power_profiles: BTreeMap<String, Profile>,
-    power_profile: u8,
-    kbd_led_brightness: u8,
-    kbd_backlight_mode: u8,
-    kbd_backlight_modes: Vec<AuraEffect>,
-}
-
-impl ConfigV212 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: self.gfx_managed,
-            active_profile: self.active_profile,
-            gfx_vfio_enable: false,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.power_profile,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
-/// for parsing old v2.2.2 config
-#[allow(dead_code)]
-#[derive(Deserialize)]
-pub(crate) struct ConfigV222 {
-    gfx_managed: bool,
-    bat_charge_limit: u8,
-    active_profile: String,
-    toggle_profiles: Vec<String>,
-    power_profiles: BTreeMap<String, Profile>,
-    power_profile: u8,
-    kbd_led_brightness: u8,
-    kbd_backlight_mode: u8,
-    kbd_backlight_modes: Vec<AuraEffect>,
-}
-
-impl ConfigV222 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.power_profile,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
-/// for parsing old v3.0.1 config
-#[derive(Deserialize, Serialize)]
-pub(crate) struct ConfigV301 {
-    pub gfx_managed: bool,
-    pub gfx_nv_mode_is_dedicated: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    // TODO: remove power_profile
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub kbd_led_brightness: u8,
-    pub kbd_backlight_mode: u8,
-    pub kbd_backlight_modes: Vec<AuraEffect>,
-    pub power_profiles: BTreeMap<String, Profile>,
-}
-
-impl ConfigV301 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
-/// for parsing old v3.1.7 config
-#[derive(Deserialize, Serialize)]
-pub(crate) struct ConfigV317 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub kbd_led_brightness: u8,
-    pub kbd_backlight_mode: u8,
-    #[serde(skip)]
-    pub kbd_backlight_modes: Option<bool>,
-    pub power_profiles: BTreeMap<String, Profile>,
-}
-
-impl ConfigV317 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: self.power_profiles,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct ConfigV324 {
-    pub gfx_mode: GfxVendors,
-    pub gfx_managed: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    #[serde(skip)]
-    pub curr_fan_mode: u8,
-    pub bat_charge_limit: u8,
-    pub power_profiles: BTreeMap<String, Profile>,
-}
-
-impl ConfigV324 {
-    pub(crate) fn into_current(self) -> Config {
-        Config {
-            gfx_mode: GfxVendors::Hybrid,
-            gfx_managed: self.gfx_managed,
-            gfx_vfio_enable: false,
-            active_profile: self.active_profile,
-            toggle_profiles: self.toggle_profiles,
-            curr_fan_mode: self.curr_fan_mode,
-            bat_charge_limit: self.bat_charge_limit,
-            power_profiles: self.power_profiles,
-        }
-    }
-}

daemon/src/ctrl_anime.rs

@@ -1,128 +0,0 @@
-use log::{error, info, warn};
-use rog_anime::{
-    usb::{
-        pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on, pkts_for_init, PROD_ID,
-        VENDOR_ID,
-    },
-    AnimeDataBuffer, AnimePacketType,
-};
-use rog_types::supported::AnimeSupportedFunctions;
-use rusb::{Device, DeviceHandle};
-use std::error::Error;
-use std::time::Duration;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-use crate::GetSupported;
-
-impl GetSupported for CtrlAnimeDisplay {
-    type A = AnimeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        AnimeSupportedFunctions(CtrlAnimeDisplay::get_device(VENDOR_ID, PROD_ID).is_ok())
-    }
-}
-
-pub struct CtrlAnimeDisplay {
-    handle: DeviceHandle<rusb::GlobalContext>,
-}
-
-impl crate::ZbusAdd for CtrlAnimeDisplay {
-    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();
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlAnimeDisplay {
-    /// Writes a data stream of length
-    fn write(&self, input: AnimeDataBuffer) {
-        self.write_data_buffer(input);
-    }
-
-    fn set_on_off(&self, status: bool) {
-        self.write_bytes(&pkt_for_set_on(status));
-    }
-
-    fn set_boot_on_off(&self, on: bool) {
-        self.write_bytes(&pkt_for_set_boot(on));
-        self.write_bytes(&pkt_for_apply());
-    }
-}
-
-impl CtrlAnimeDisplay {
-    #[inline]
-    pub fn new() -> Result<CtrlAnimeDisplay, Box<dyn Error>> {
-        // We don't expect this ID to ever change
-        let device = CtrlAnimeDisplay::get_device(0x0b05, 0x193b)?;
-
-        let mut device = device.open()?;
-        device.reset()?;
-
-        device.set_auto_detach_kernel_driver(true).map_err(|err| {
-            error!("Auto-detach kernel driver failed: {}", err);
-            err
-        })?;
-
-        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {}", err);
-            err
-        })?;
-
-        info!("Device has an AniMe Matrix display");
-        let ctrl = CtrlAnimeDisplay { handle: device };
-        ctrl.do_initialization();
-
-        Ok(ctrl)
-    }
-
-    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
-        for device in rusb::devices()?.iter() {
-            let device_desc = device.device_descriptor()?;
-            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return Ok(device);
-            }
-        }
-        Err(rusb::Error::NoDevice)
-    }
-
-    fn write_bytes(&self, message: &[u8]) {
-        match self.handle.write_control(
-            0x21,  // request_type
-            0x09,  // request
-            0x35e, // value
-            0x00,  // index
-            message,
-            Duration::from_millis(200),
-        ) {
-            Ok(_) => {}
-            Err(err) => match err {
-                rusb::Error::Timeout => {}
-                _ => error!("Failed to write to led interrupt: {}", err),
-            },
-        }
-    }
-
-    fn write_data_buffer(&self, buffer: AnimeDataBuffer) {
-        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]);
-    }
-}

daemon/src/ctrl_anime/config.rs

@@ -0,0 +1,272 @@
+use crate::VERSION;
+use log::{error, info, warn};
+use rog_anime::{error::AnimeError, ActionData, ActionLoader, AnimTime, Vec2};
+use rog_anime::{AnimeType, Fade};
+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,
+        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)]
+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(mut data) = serde_json::from_str(&buf) {
+                    Self::clamp_config_brightness(&mut data);
+                    return data;
+                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV341>(&buf) {
+                    let mut config = data.into_current();
+                    config.write();
+                    info!("Updated config version to: {}", VERSION);
+                    Self::clamp_config_brightness(&mut config);
+                    return config;
+                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV352>(&buf) {
+                    let mut config = data.into_current();
+                    config.write();
+                    info!("Updated config version to: {}", VERSION);
+                    Self::clamp_config_brightness(&mut config);
+                    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 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(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

@@ -0,0 +1,209 @@
+pub mod config;
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
+pub mod trait_impls;
+
+use self::config::{AnimeConfig, AnimeConfigCached};
+use crate::{error::RogError, GetSupported};
+use ::zbus::export::futures_util::lock::Mutex;
+use log::{error, info, warn};
+use rog_anime::{
+    error::AnimeError,
+    usb::{get_anime_type, pkt_for_flush, pkts_for_init},
+    ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
+};
+use rog_platform::{hid_raw::HidRaw, supported::AnimeSupportedFunctions, usb_raw::USBRaw};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::{convert::TryFrom, error::Error, sync::Arc, thread::sleep};
+
+impl GetSupported for CtrlAnime {
+    type A = AnimeSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
+    }
+}
+
+pub struct CtrlAnime {
+    node: USBRaw,
+    anime_type: AnimeType,
+    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 = USBRaw::new(0x193b)?;
+        let anime_type = get_anime_type()?;
+
+        info!("Device has an AniMe Matrix display");
+        let mut cache = AnimeConfigCached::default();
+        cache.init_from_config(&config, anime_type)?;
+
+        let ctrl = CtrlAnime {
+            node,
+            anime_type,
+            cache,
+            config,
+            thread_exit: Arc::new(AtomicBool::new(false)),
+            thread_running: Arc::new(AtomicBool::new(false)),
+        };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
+    }
+    // let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
+
+    /// Start an action thread. This is classed as a singleton and there should be only
+    /// one running - so the thread uses atomics to signal run/exit.
+    ///
+    /// 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
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main thread)
+        std::thread::Builder::new()
+            .name("AniMe system thread start".into())
+            .spawn(move || {
+                info!("AniMe new system thread started");
+                // Getting copies of these Atomics is done *in* the thread to ensure
+                // we don't block other threads/main
+                let thread_exit;
+                let thread_running;
+                let anime_type;
+                loop {
+                    if let Some(lock) = inner.try_lock() {
+                        thread_exit = lock.thread_exit.clone();
+                        thread_running = lock.thread_running.clone();
+                        anime_type = lock.anime_type;
+                        break;
+                    }
+                }
+                // First two loops are to ensure we *do* aquire a lock on the mutex
+                // The reason the loop is required is because the USB writes can block
+                // for up to 10ms. We can't fail to get the atomics.
+                while thread_running.load(Ordering::SeqCst) {
+                    // Make any running loop exit first
+                    thread_exit.store(true, Ordering::SeqCst);
+                }
+
+                info!("AniMe no previous system thread running (now)");
+                thread_exit.store(false, Ordering::SeqCst);
+
+                'main: loop {
+                    thread_running.store(true, Ordering::SeqCst);
+                    for action in &actions {
+                        if thread_exit.load(Ordering::SeqCst) {
+                            break 'main;
+                        }
+                        match action {
+                            ActionData::Animation(frames) => {
+                                rog_anime::run_animation(frames, &|frame| {
+                                    if thread_exit.load(Ordering::Acquire) {
+                                        info!("rog-anime: frame-loop was asked to exit");
+                                        return Ok(true); // Do safe exit
+                                    }
+                                    inner
+                                        .try_lock()
+                                        .map(|lock| {
+                                            lock.write_data_buffer(frame)
+                                                .map_err(|err| {
+                                                    warn!(
+                                                        "rog_anime::run_animation:callback {}",
+                                                        err
+                                                    );
+                                                })
+                                                .ok();
+                                            false // Don't exit yet
+                                        })
+                                        .map_or_else(
+                                            || {
+                                                warn!("rog_anime::run_animation:callback failed");
+                                                Err(AnimeError::NoFrames)
+                                            },
+                                            Ok,
+                                        )
+                                });
+                            }
+                            ActionData::Image(image) => {
+                                once = false;
+                                if let Some(lock) = inner.try_lock() {
+                                    lock.write_data_buffer(image.as_ref().clone())
+                                        .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 Some(lock) = inner.try_lock() {
+                    if let Ok(data) =
+                        AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()])
+                            .map_err(|e| error!("{}", e))
+                    {
+                        lock.write_data_buffer(data)
+                            .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");
+            })
+            .map(|err| info!("AniMe system thread: {:?}", err))
+            .ok();
+    }
+
+    /// Write only a data packet. This will modify the leds brightness using the
+    /// global brightness set in config.
+    fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> {
+        for led in buffer.data_mut().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::try_from(buffer)?;
+        for row in &data {
+            self.node.write_bytes(row)?;
+        }
+        self.node.write_bytes(&pkt_for_flush())?;
+        Ok(())
+    }
+
+    fn do_initialization(&self) -> Result<(), RogError> {
+        let pkts = pkts_for_init();
+        self.node.write_bytes(&pkts[0])?;
+        self.node.write_bytes(&pkts[1])?;
+        Ok(())
+    }
+}

daemon/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,220 @@
+use super::CtrlAnime;
+use crate::error::RogError;
+use async_trait::async_trait;
+use log::{info, warn};
+use rog_anime::{
+    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
+    AnimeDataBuffer, AnimePowerStates,
+};
+use std::sync::{atomic::Ordering, Arc};
+use zbus::{
+    dbus_interface,
+    export::futures_util::lock::{Mutex, MutexGuard},
+    Connection, SignalContext,
+};
+
+pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Anime";
+
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
+
+/// The struct with the main dbus methods requires this trait
+#[async_trait]
+impl crate::ZbusRun for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not grab it
+// until we finish.
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until it is restarted
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        let lock = self.0.lock().await;
+        lock.thread_exit.store(true, Ordering::SeqCst);
+        lock.write_data_buffer(input).map_err(|err| {
+            warn!("rog_anime::run_animation:callback {}", err);
+            err
+        })?;
+        Ok(())
+    }
+
+    /// Set the global AniMe brightness
+    async fn set_brightness(&self, bright: f32) {
+        let mut lock = self.0.lock().await;
+        let mut bright = bright;
+        if bright < 0.0 {
+            bright = 0.0;
+        } else if bright > 1.0 {
+            bright = 1.0;
+        }
+        lock.config.brightness = bright;
+        lock.config.write();
+    }
+
+    /// Set whether the AniMe is displaying images/data
+    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_on(status))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.awake_enabled = status;
+        lock.config.write();
+
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// Set whether the AniMe will show boot, suspend, or off animations
+    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_boot(on))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&pkt_for_apply())
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.boot_anim_enabled = on;
+        lock.config.write();
+
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// 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 {
+            let lock = self.0.lock().await;
+            lock.thread_exit.store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
+        }
+    }
+
+    /// Get status of if the AniMe LEDs are on/displaying while system is awake
+    #[dbus_interface(property)]
+    async fn awake_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.awake_enabled
+    }
+
+    /// Get the status of if factory system-status animations are enabled
+    #[dbus_interface(property)]
+    async fn boot_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.boot_anim_enabled
+    }
+
+    /// Notify listeners of the status of AniMe LED power and factory system-status animations
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        ctxt: &SignalContext<'_>,
+        data: AnimePowerStates,
+    ) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let run_action =
+            |start: bool, lock: MutexGuard<'_, CtrlAnime>, inner: Arc<Mutex<CtrlAnime>>| {
+                if start {
+                    info!("CtrlAnimeTask running sleep animation");
+                    CtrlAnime::run_thread(inner, lock.cache.shutdown.clone(), true);
+                } else {
+                    info!("CtrlAnimeTask running wake animation");
+                    CtrlAnime::run_thread(inner, lock.cache.wake.clone(), true);
+                }
+            };
+
+        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(
+            // Loop is required to try an attempt to get the mutex *without* blocking
+            // other threads - it is possible to end up with deadlocks otherwise.
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    run_action(true, lock, inner1.clone());
+                }
+            },
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    run_action(true, lock, inner2.clone());
+                }
+            },
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    run_action(true, lock, inner3.clone());
+                }
+            },
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    run_action(true, lock, inner4.clone());
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlAnimeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
+            lock.node
+                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+            lock.node
+                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+
+            let action = lock.cache.boot.clone();
+            CtrlAnime::run_thread(self.0.clone(), action, true);
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_aura/config.rs

@@ -0,0 +1,423 @@
+use crate::laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
+use log::{error, warn};
+use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardLed;
+use serde_derive::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashSet};
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
+
+/// Enable/disable LED control in various states such as
+/// when the device is awake, suspended, shutting down or
+/// booting.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AuraPowerConfig {
+    AuraDevTuf(HashSet<AuraDevTuf>),
+    AuraDev1866(HashSet<AuraDev1866>),
+    AuraDev19b6(HashSet<AuraDev19b6>),
+}
+
+impl AuraPowerConfig {
+    /// Invalid for TUF laptops
+    pub fn to_bytes(control: &Self) -> [u8; 3] {
+        match control {
+            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
+            AuraPowerConfig::AuraDev1866(c) => {
+                let c: Vec<AuraDev1866> = c.iter().copied().collect();
+                AuraDev1866::to_bytes(&c)
+            }
+            AuraPowerConfig::AuraDev19b6(c) => {
+                let c: Vec<AuraDev19b6> = c.iter().copied().collect();
+                AuraDev19b6::to_bytes(&c)
+            }
+        }
+    }
+
+    pub fn to_tuf_bool_array(control: &Self) -> Option<[bool; 5]> {
+        if let Self::AuraDevTuf(c) = control {
+            return Some([
+                true,
+                c.contains(&AuraDevTuf::Boot),
+                c.contains(&AuraDevTuf::Awake),
+                c.contains(&AuraDevTuf::Sleep),
+                c.contains(&AuraDevTuf::Keyboard),
+            ]);
+        }
+
+        if let Self::AuraDev1866(c) = control {
+            return Some([
+                true,
+                c.contains(&AuraDev1866::Boot),
+                c.contains(&AuraDev1866::Awake),
+                c.contains(&AuraDev1866::Sleep),
+                c.contains(&AuraDev1866::Keyboard),
+            ]);
+        }
+
+        None
+    }
+
+    pub fn set_tuf(&mut self, power: AuraDevTuf, on: bool) {
+        if let Self::AuraDevTuf(p) = self {
+            if on {
+                p.insert(power);
+            } else {
+                p.remove(&power);
+            }
+        }
+    }
+    pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) {
+        if let Self::AuraDev1866(p) = self {
+            if on {
+                p.insert(power);
+            } else {
+                p.remove(&power);
+            }
+        }
+    }
+
+    pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) {
+        if let Self::AuraDev19b6(p) = self {
+            if on {
+                p.insert(power);
+            } else {
+                p.remove(&power);
+            }
+        }
+    }
+}
+
+impl From<&AuraPowerConfig> for AuraPowerDev {
+    fn from(config: &AuraPowerConfig) -> Self {
+        match config {
+            AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
+                tuf: d.iter().copied().collect(),
+                x1866: vec![],
+                x19b6: vec![],
+            },
+            AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
+                tuf: vec![],
+                x1866: d.iter().copied().collect(),
+                x19b6: vec![],
+            },
+            AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
+                tuf: vec![],
+                x1866: vec![],
+                x19b6: d.iter().copied().collect(),
+            },
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+// #[serde(default)]
+pub struct AuraConfig {
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
+    pub multizone_on: bool,
+    pub enabled: AuraPowerConfig,
+}
+
+impl Default for AuraConfig {
+    fn default() -> Self {
+        let mut prod_id = AuraDevice::Unknown;
+        for prod in &ASUS_KEYBOARD_DEVICES {
+            if HidRaw::new(prod).is_ok() {
+                prod_id = AuraDevice::from(*prod);
+                break;
+            }
+        }
+
+        if prod_id == AuraDevice::Unknown {
+            if let Ok(p) = KeyboardLed::new() {
+                if p.has_kbd_rgb_mode() {
+                    prod_id = AuraDevice::Tuf;
+                }
+            }
+        }
+
+        let enabled = if prod_id == AuraDevice::X19B6 {
+            AuraPowerConfig::AuraDev19b6(HashSet::from([
+                AuraDev19b6::BootLogo,
+                AuraDev19b6::BootKeyb,
+                AuraDev19b6::SleepLogo,
+                AuraDev19b6::SleepKeyb,
+                AuraDev19b6::AwakeLogo,
+                AuraDev19b6::AwakeKeyb,
+                AuraDev19b6::ShutdownLogo,
+                AuraDev19b6::ShutdownKeyb,
+                AuraDev19b6::BootBar,
+                AuraDev19b6::AwakeBar,
+                AuraDev19b6::SleepBar,
+                AuraDev19b6::ShutdownBar,
+            ]))
+        } else if prod_id == AuraDevice::Tuf {
+            AuraPowerConfig::AuraDevTuf(HashSet::from([
+                AuraDevTuf::Awake,
+                AuraDevTuf::Boot,
+                AuraDevTuf::Sleep,
+                AuraDevTuf::Keyboard,
+            ]))
+        } else {
+            AuraPowerConfig::AuraDev1866(HashSet::from([
+                AuraDev1866::Awake,
+                AuraDev1866::Boot,
+                AuraDev1866::Sleep,
+                AuraDev1866::Keyboard,
+                AuraDev1866::Lightbar,
+            ]))
+        };
+
+        AuraConfig {
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+            multizone_on: false,
+            enabled,
+        }
+    }
+}
+
+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;
+                }
+                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));
+
+            if !support_data.multizone.is_empty() {
+                let mut default = vec![];
+                for (i, tmp) in support_data.multizone.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);
+                }
+            }
+        }
+
+        // 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 = 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));
+    }
+
+    /// 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) = multi.get_mut(effect.mode()) {
+                    for fx in fx.iter_mut() {
+                        if fx.zone == effect.zone {
+                            *fx = effect;
+                            return;
+                        }
+                    }
+                    fx.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
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::AuraConfig;
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+
+    #[test]
+    fn set_multizone_4key_config() {
+        let mut config = AuraConfig::default();
+
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0x00, 0xff),
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 0xff),
+            zone: AuraZone::Key2,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0xff, 0x00),
+            zone: AuraZone::Key3,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 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(0xff, 0x00, 0xff));
+        assert_eq!(sta[1].colour1, Colour(0x00, 0xff, 0xff));
+        assert_eq!(sta[2].colour1, Colour(0xff, 0xff, 0x00));
+        assert_eq!(sta[3].colour1, Colour(0x00, 0xff, 0x00));
+    }
+
+    #[test]
+    fn set_multizone_multimode_config() {
+        let mut config = AuraConfig::default();
+
+        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);
+    }
+}

daemon/src/ctrl_aura/controller.rs

@@ -0,0 +1,509 @@
+use crate::{
+    error::RogError,
+    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
+};
+use log::{info, warn};
+use rog_aura::{
+    usb::{AuraDevice, LED_APPLY, LED_SET},
+    AuraEffect, KeyColourArray, LedBrightness, PerKeyRaw, LED_MSG_LEN,
+};
+use rog_aura::{AuraZone, Direction, Speed, GRADIENT};
+use rog_platform::{hid_raw::HidRaw, keyboard_led::KeyboardLed, supported::LedSupportedFunctions};
+use std::collections::BTreeMap;
+
+use crate::GetSupported;
+
+use super::config::{AuraConfig, AuraPowerConfig};
+
+impl GetSupported for CtrlKbdLed {
+    type A = LedSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        // let mode = <&str>::from(&<AuraModes>::from(*mode));
+        let laptop = LaptopLedData::get_data();
+        let stock_led_modes = laptop.standard;
+        let multizone_led_mode = laptop.multizone;
+        let per_key_led_mode = laptop.per_key;
+
+        let mut prod_id = AuraDevice::Unknown;
+        for prod in &ASUS_KEYBOARD_DEVICES {
+            if HidRaw::new(prod).is_ok() {
+                prod_id = AuraDevice::from(*prod);
+                break;
+            }
+        }
+
+        let rgb = KeyboardLed::new();
+        if let Ok(p) = rgb.as_ref() {
+            if p.has_kbd_rgb_mode() {
+                prod_id = AuraDevice::Tuf;
+            }
+        }
+
+        LedSupportedFunctions {
+            prod_id,
+            brightness_set: rgb.is_ok(),
+            stock_led_modes,
+            multizone_led_mode,
+            per_key_led_mode,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd)]
+pub enum LEDNode {
+    KbdLed(KeyboardLed),
+    Rog(HidRaw),
+    None,
+}
+
+pub struct CtrlKbdLed {
+    // TODO: config stores the keyboard type as an AuraPower, use or update this
+    pub led_prod: Option<String>,
+    pub led_node: LEDNode,
+    pub kd_brightness: KeyboardLed,
+    pub supported_modes: LaptopLedData,
+    pub flip_effect_write: bool,
+    pub per_key_mode_active: bool,
+    pub config: AuraConfig,
+}
+
+impl CtrlKbdLed {
+    pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
+        let mut led_prod = None;
+        let mut led_node = None;
+        for prod in &ASUS_KEYBOARD_DEVICES {
+            match HidRaw::new(prod) {
+                Ok(node) => {
+                    led_prod = Some((*prod).to_owned());
+                    led_node = Some(node);
+                    info!("Looked for keyboard controller 0x{prod}: Found");
+                    break;
+                }
+                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
+            }
+        }
+
+        let rgb_led = KeyboardLed::new()?;
+
+        if led_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
+            let dmi = sysfs_class::DmiId::default();
+            if let Ok(prod_family) = dmi.product_family() {
+                if prod_family.contains("TUF") {
+                    warn!("A kernel patch is in progress for TUF RGB support");
+                }
+            }
+            return Err(RogError::NoAuraKeyboard);
+        }
+
+        let led_node = if let Some(rog) = led_node {
+            info!("Found ROG USB keyboard");
+            LEDNode::Rog(rog)
+        } else if rgb_led.has_kbd_rgb_mode() {
+            info!("Found TUF keyboard");
+            LEDNode::KbdLed(rgb_led.clone())
+        } else {
+            LEDNode::None
+        };
+
+        let ctrl = CtrlKbdLed {
+            led_prod,
+            led_node,
+            kd_brightness: rgb_led, // If was none then we already returned above
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config,
+        };
+        Ok(ctrl)
+    }
+
+    pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
+        self.kd_brightness
+            .get_brightness()
+            .map_err(RogError::Platform)
+    }
+
+    pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
+        self.kd_brightness
+            .set_brightness(brightness as u8)
+            .map_err(RogError::Platform)
+    }
+
+    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 combination state for boot animation/sleep animation/all leds/keys leds/side leds LED active
+    pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &mut self.led_node {
+            if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
+                let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8];
+                platform.set_kbd_rgb_state(&buf)?;
+            }
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
+            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2]];
+
+            hid_raw.write_bytes(&message)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        }
+        Ok(())
+    }
+
+    /// 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.
+    pub(crate) fn set_effect(&mut self, effect: AuraEffect) -> Result<(), RogError> {
+        if !self.supported_modes.standard.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !self.supported_modes.multizone.contains(&effect.zone)
+        {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        self.write_mode(&effect)?;
+        self.config.read(); // refresh config if successful
+        self.config.set_builtin(effect);
+        self.config.write();
+        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 fn write_effect_block(&mut self, effect: &PerKeyRaw) -> Result<(), RogError> {
+        let pkt_type = effect[0][1];
+        const PER_KEY_TYPE: u8 = 0xbc;
+
+        if pkt_type != PER_KEY_TYPE {
+            self.per_key_mode_active = false;
+            if let LEDNode::Rog(hid_raw) = &self.led_node {
+                hid_raw.write_bytes(&effect[0])?;
+                hid_raw.write_bytes(&LED_SET)?;
+                // hid_raw.write_bytes(&LED_APPLY)?;
+            }
+        } else {
+            if !self.per_key_mode_active {
+                if let LEDNode::Rog(hid_raw) = &self.led_node {
+                    let init = KeyColourArray::get_init_msg();
+                    hid_raw.write_bytes(&init)?;
+                }
+                self.per_key_mode_active = true;
+            }
+            if let LEDNode::Rog(hid_raw) = &self.led_node {
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
+            } else if let LEDNode::KbdLed(tuf) = &self.led_node {
+                for row in effect.iter() {
+                    let r = row[9];
+                    let g = row[10];
+                    let b = row[11];
+                    tuf.set_kbd_rgb_mode(&[0, 0, r, g, b, 0])?;
+                }
+            }
+            self.flip_effect_write = !self.flip_effect_write;
+        }
+        Ok(())
+    }
+
+    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 self.config.builtins.contains_key(&next) {
+            self.config.current_mode = next;
+            self.write_current_config_mode()?;
+            // }
+            self.config.write();
+        }
+
+        Ok(())
+    }
+
+    fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &self.led_node {
+            let buf = [
+                1,
+                mode.mode as u8,
+                mode.colour1.0,
+                mode.colour1.1,
+                mode.colour1.2,
+                mode.speed as u8,
+            ];
+            platform.set_kbd_rgb_mode(&buf)?;
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes: [u8; LED_MSG_LEN] = mode.into();
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
+        }
+        self.per_key_mode_active = false;
+        Ok(())
+    }
+
+    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
+        if self.config.multizone_on {
+            let mode = self.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 self.config.multizone.is_none() {
+                create = true;
+            } else if let Some(multizones) = self.config.multizone.as_ref() {
+                if !multizones.contains_key(&mode) {
+                    create = true;
+                }
+            }
+            if create {
+                info!("No user-set config for zone founding, attempting a default");
+                self.create_multizone_default()?;
+            }
+
+            if let Some(multizones) = self.config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_mode(&mode)?;
+                    }
+                }
+            }
+        } else {
+            let mode = self.config.current_mode;
+            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
+                self.write_mode(&effect)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Create a default for the `current_mode` if multizone and no config exists.
+    fn create_multizone_default(&mut self) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in self.supported_modes.multizone.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.config.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.config.multizone.as_mut() {
+            multizones.insert(self.config.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.config.current_mode, default);
+            self.config.multizone = Some(tmp);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+    use rog_platform::keyboard_led::KeyboardLed;
+
+    use crate::{
+        ctrl_aura::{config::AuraConfig, controller::LEDNode},
+        laptops::LaptopLedData,
+    };
+
+    use super::CtrlKbdLed;
+
+    #[test]
+    // #[ignore = "Must be manually run due to detection stage"]
+    fn check_set_mode_errors() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::default();
+        let supported_modes = LaptopLedData {
+            prod_family: String::new(),
+            board_names: vec![],
+            standard: vec![AuraModeNum::Static],
+            multizone: vec![],
+            per_key: false,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: None,
+            led_node: LEDNode::None,
+            kd_brightness: KeyboardLed::default(),
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config,
+        };
+
+        let mut effect = AuraEffect {
+            colour1: Colour(0xff, 0x00, 0xff),
+            zone: AuraZone::None,
+            ..Default::default()
+        };
+
+        // This error comes from write_bytes because we don't have a keyboard node stored
+        assert_eq!(
+            controller
+                .set_effect(effect.clone())
+                .unwrap_err()
+                .to_string(),
+            "No supported Aura keyboard"
+        );
+
+        effect.mode = AuraModeNum::Laser;
+        assert_eq!(
+            controller
+                .set_effect(effect.clone())
+                .unwrap_err()
+                .to_string(),
+            "Aura effect not supported"
+        );
+
+        effect.mode = AuraModeNum::Static;
+        effect.zone = AuraZone::Key2;
+        assert_eq!(
+            controller
+                .set_effect(effect.clone())
+                .unwrap_err()
+                .to_string(),
+            "Aura effect not supported"
+        );
+
+        controller.supported_modes.multizone.push(AuraZone::Key2);
+        assert_eq!(
+            controller.set_effect(effect).unwrap_err().to_string(),
+            "No supported Aura keyboard"
+        );
+    }
+
+    #[test]
+    fn create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::default();
+        let supported_modes = LaptopLedData {
+            prod_family: String::new(),
+            board_names: vec![],
+            standard: vec![AuraModeNum::Static],
+            multizone: vec![],
+            per_key: false,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: None,
+            led_node: LEDNode::None,
+            kd_brightness: KeyboardLed::default(),
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config,
+        };
+
+        assert!(controller.config.multizone.is_none());
+        assert!(controller.create_multizone_default().is_err());
+        assert!(controller.config.multizone.is_none());
+
+        controller.supported_modes.multizone.push(AuraZone::Key1);
+        controller.supported_modes.multizone.push(AuraZone::Key2);
+        assert!(controller.create_multizone_default().is_ok());
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+
+    #[test]
+    fn next_mode_create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::default();
+        let supported_modes = LaptopLedData {
+            prod_family: String::new(),
+            board_names: vec![],
+            standard: vec![AuraModeNum::Static],
+            multizone: vec![AuraZone::Key1, AuraZone::Key2],
+            per_key: false,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: None,
+            led_node: LEDNode::None,
+            kd_brightness: KeyboardLed::default(),
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config,
+        };
+
+        assert!(controller.config.multizone.is_none());
+        controller.config.multizone_on = true;
+        // This is called in toggle_mode. It will error here because we have no
+        // keyboard node in tests.
+        assert_eq!(
+            controller
+                .write_current_config_mode()
+                .unwrap_err()
+                .to_string(),
+            "No supported Aura keyboard"
+        );
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+}

daemon/src/ctrl_aura/mod.rs

@@ -0,0 +1,4 @@
+pub mod config;
+pub mod controller;
+/// Implements CtrlTask, Reloadable, ZbusRun
+pub mod trait_impls;

daemon/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,324 @@
+use async_trait::async_trait;
+use log::{error, info, warn};
+use rog_aura::{usb::AuraPowerDev, AuraEffect, AuraModeNum, LedBrightness, PerKeyRaw};
+use std::{collections::BTreeMap, sync::Arc};
+use zbus::{
+    dbus_interface,
+    export::futures_util::{
+        lock::{Mutex, MutexGuard},
+        StreamExt,
+    },
+    Connection, SignalContext,
+};
+
+use crate::{error::RogError, CtrlTask};
+
+use super::controller::CtrlKbdLed;
+
+pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Aura";
+
+#[derive(Clone)]
+pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
+
+impl CtrlKbdLedZbus {
+    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
+        let bright = lock.kd_brightness.get_brightness()?;
+        lock.config.read();
+        lock.config.brightness = (bright as u32).into();
+        lock.config.write();
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlKbdLedZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+/// The main interface for changing, reading, or notfying signals
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlKbdLedZbus {
+    /// Set the keyboard brightness level (0-3)
+    async fn set_brightness(&mut self, brightness: LedBrightness) {
+        let ctrl = self.0.lock().await;
+        ctrl.set_brightness(brightness)
+            .map_err(|err| warn!("{}", err))
+            .ok();
+    }
+
+    /// Set a variety of states, input is array of enum.
+    /// `enabled` sets if the sent array should be disabled or enabled
+    ///
+    /// ```text
+    /// pub struct AuraPowerDev {
+    ///     pub x1866: Vec<AuraDev1866>,
+    ///     pub x19b6: Vec<AuraDev19b6>,
+    /// }
+    /// pub enum AuraDev1866 {
+    ///     Awake,
+    ///     Keyboard,
+    ///     Lightbar,
+    ///     Boot,
+    ///     Sleep,
+    /// }
+    /// enum AuraDev19b6 {
+    ///     BootLogo,
+    ///     BootKeyb,
+    ///     AwakeLogo,
+    ///     AwakeKeyb,
+    ///     SleepLogo,
+    ///     SleepKeyb,
+    ///     ShutdownLogo,
+    ///     ShutdownKeyb,
+    ///     AwakeBar,
+    ///     BootBar,
+    ///     SleepBar,
+    ///     ShutdownBar,
+    /// }
+    /// ```
+    async fn set_leds_power(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        options: AuraPowerDev,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        for p in options.tuf {
+            ctrl.config.enabled.set_tuf(p, enabled);
+        }
+        for p in options.x1866 {
+            ctrl.config.enabled.set_0x1866(p, enabled);
+        }
+        for p in options.x19b6 {
+            ctrl.config.enabled.set_0x19b6(p, enabled);
+        }
+
+        ctrl.config.write();
+
+        ctrl.set_power_states().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        Self::notify_power_states(&ctxt, &AuraPowerDev::from(&ctrl.config.enabled))
+            .await
+            .unwrap_or_else(|err| warn!("{}", err));
+        Ok(())
+    }
+
+    async fn set_led_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        effect: AuraEffect,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.set_effect(effect).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+        Ok(())
+    }
+
+    async fn next_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.toggle_mode(false).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+
+        Ok(())
+    }
+
+    async fn prev_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.toggle_mode(true).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+
+        Ok(())
+    }
+
+    async fn next_led_brightness(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.next_brightness().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+        Ok(())
+    }
+
+    async fn prev_led_brightness(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.prev_brightness().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+        Ok(())
+    }
+
+    // As property doesn't work for AuraPowerDev (complexity of serialization?)
+    // #[dbus_interface(property)]
+    async fn leds_enabled(&self) -> AuraPowerDev {
+        let ctrl = self.0.lock().await;
+        AuraPowerDev::from(&ctrl.config.enabled)
+    }
+
+    /// Return the current mode data
+    async fn led_mode(&self) -> AuraModeNum {
+        let ctrl = self.0.lock().await;
+        ctrl.config.current_mode
+    }
+
+    /// Return a list of available modes
+    async fn led_modes(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
+        let ctrl = self.0.lock().await;
+        ctrl.config.builtins.clone()
+    }
+
+    async fn per_key_raw(&self, data: PerKeyRaw) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_effect_block(&data)?;
+        Ok(())
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    async fn led_brightness(&self) -> i8 {
+        let ctrl = self.0.lock().await;
+        ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        signal_ctxt: &SignalContext<'_>,
+        data: &AuraPowerDev,
+    ) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl CtrlTask for CtrlKbdLedZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save = |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| {
+            // If waking up
+            if !start {
+                info!("CtrlKbdLedTask reloading brightness and modes");
+                lock.set_brightness(lock.config.brightness)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+                lock.write_current_config_mode()
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            } else if start {
+                info!("CtrlKbdLedTask saving last brightness");
+                Self::update_config(&mut lock)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            }
+        };
+
+        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(
+            // Loop so that we do aquire the lock but also don't block other
+            // threads (prevents potential deadlocks)
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    load_save(true, lock);
+                }
+            },
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    load_save(false, lock);
+                }
+            },
+        )
+        .await;
+
+        let ctrl2 = self.0.clone();
+        let ctrl = self.0.lock().await;
+        let mut watch = ctrl.kd_brightness.monitor_brightness()?;
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    if let Some(lock) = ctrl2.try_lock() {
+                        load_save(true, lock);
+                    }
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlKbdLedZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_current_config_mode()?;
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

daemon/src/ctrl_charge.rs

@@ -1,123 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
-use rog_types::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_PATH: &str = "/sys/class/power_supply/BAT0/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) {
-        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();
-        }
-    }
-
-    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_PATH).exists() {
-            Ok(BAT_CHARGE_PATH)
-        } 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) {
-            warn!(
-                "Unable to set battery charge limit, must be between 20-100: requested {}",
-                limit
-            );
-        }
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(BAT_CHARGE_PATH)
-            .map_err(|err| RogError::Path(BAT_CHARGE_PATH.into(), err))?;
-        file.write_all(limit.to_string().as_bytes())
-            .map_err(|err| RogError::Write(BAT_CHARGE_PATH.into(), err))?;
-        info!("Battery charge limit: {}", limit);
-
-        config.read();
-        config.bat_charge_limit = limit;
-        config.write();
-
-        Ok(())
-    }
-}

daemon/src/ctrl_fan_cpu.rs

@@ -1,394 +0,0 @@
-use crate::error::RogError;
-use crate::{config::Config, GetSupported};
-use log::{info, warn};
-use rog_types::{profile::{FanLevel, Profile, ProfileEvent}, supported::FanCpuSupportedFunctions};
-use std::fs::OpenOptions;
-use std::io::Write;
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::{dbus_interface, fdo::Error};
-use zvariant::ObjectPath;
-
-static FAN_TYPE_1_PATH: &str = "/sys/devices/platform/asus-nb-wmi/throttle_thermal_policy";
-static FAN_TYPE_2_PATH: &str = "/sys/devices/platform/asus-nb-wmi/fan_boost_mode";
-static AMD_BOOST_PATH: &str = "/sys/devices/system/cpu/cpufreq/boost";
-
-pub struct CtrlFanAndCpu {
-    pub path: &'static str,
-    config: Arc<Mutex<Config>>,
-}
-
-impl GetSupported for CtrlFanAndCpu {
-    type A = FanCpuSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        FanCpuSupportedFunctions {
-            stock_fan_modes: CtrlFanAndCpu::get_fan_path().is_ok(),
-            min_max_freq: intel_pstate::PState::new().is_ok(),
-            fan_curve_set: rog_fan_curve::Board::from_board_name().is_some(),
-        }
-    }
-}
-
-pub struct DbusFanAndCpu {
-    inner: Arc<Mutex<CtrlFanAndCpu>>,
-}
-
-impl DbusFanAndCpu {
-    pub fn new(inner: Arc<Mutex<CtrlFanAndCpu>>) -> Self {
-        Self { inner }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl DbusFanAndCpu {
-    /// Set profile details
-    fn set_profile(&self, profile: String) {
-        if let Ok(event) = serde_json::from_str(&profile) {
-            if let Ok(mut ctrl) = self.inner.try_lock() {
-                if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                    cfg.read();
-                    ctrl.handle_profile_event(&event, &mut cfg)
-                        .unwrap_or_else(|err| warn!("{}", err));
-                    if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                        if let Ok(json) = serde_json::to_string(profile) {
-                            self.notify_profile(&json)
-                                .unwrap_or_else(|err| warn!("{}", err));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /// Fetch the active profile name
-    fn next_profile(&mut self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                cfg.read();
-                ctrl.do_next_profile(&mut cfg)
-                    .unwrap_or_else(|err| warn!("{}", err));
-                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                    if let Ok(json) = serde_json::to_string(profile) {
-                        self.notify_profile(&json)
-                            .unwrap_or_else(|err| warn!("{}", err));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Fetch the active profile name
-    fn active_profile_name(&mut self) -> zbus::fdo::Result<String> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                return Ok(cfg.active_profile.clone());
-            }
-        }
-        Err(Error::Failed(
-            "Failed to get active profile name".to_string(),
-        ))
-    }
-
-    // TODO: Profile can't implement Type because of Curve
-    /// Fetch the active profile details
-    fn profile(&mut self) -> zbus::fdo::Result<String> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                    if let Ok(json) = serde_json::to_string_pretty(profile) {
-                        return Ok(json);
-                    }
-                }
-            }
-        }
-        Err(Error::Failed(
-            "Failed to get active profile details".to_string(),
-        ))
-    }
-
-    /// Fetch all profile data
-    fn profiles(&mut self) -> zbus::fdo::Result<String> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                if let Ok(json) = serde_json::to_string_pretty(&cfg.power_profiles) {
-                    return Ok(json);
-                }
-            }
-        }
-        Err(Error::Failed(
-            "Failed to get all profile details".to_string(),
-        ))
-    }
-
-    fn profile_names(&self) -> zbus::fdo::Result<Vec<String>> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                let profile_names = cfg.power_profiles.keys().cloned().collect::<Vec<String>>();
-                return Ok(profile_names);
-            }
-        }
-
-        Err(Error::Failed("Failed to get all profile names".to_string()))
-    }
-
-    fn remove(&self, profile: &str) -> zbus::fdo::Result<()> {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-
-                if !cfg.power_profiles.contains_key(profile) {
-                    return Err(Error::Failed("Invalid profile specified".to_string()));
-                }
-
-                if cfg.power_profiles.keys().len() == 1 {
-                    return Err(Error::Failed("Cannot delete the last profile".to_string()));
-                }
-
-                if cfg.active_profile == *profile {
-                    return Err(Error::Failed(
-                        "Cannot delete the active profile".to_string(),
-                    ));
-                }
-
-                cfg.power_profiles.remove(profile);
-                cfg.write();
-
-                return Ok(());
-            }
-        }
-
-        Err(Error::Failed("Failed to lock configuration".to_string()))
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_profile(&self, profile: &str) -> zbus::Result<()> {}
-}
-
-impl crate::ZbusAdd for DbusFanAndCpu {
-    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();
-    }
-}
-
-impl crate::Reloadable for CtrlFanAndCpu {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            let profile = config.active_profile.clone();
-            self.set(&profile, &mut config)?;
-            // info!(
-            //     "Reloaded fan mode: {:?}",
-            //     FanLevel::from(config.power_profile)
-            // );
-        }
-        Ok(())
-    }
-}
-
-impl CtrlFanAndCpu {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        let path = CtrlFanAndCpu::get_fan_path()?;
-        info!("Device has thermal throttle control");
-        Ok(CtrlFanAndCpu { path, config })
-    }
-
-    fn get_fan_path() -> Result<&'static str, RogError> {
-        if Path::new(FAN_TYPE_1_PATH).exists() {
-            Ok(FAN_TYPE_1_PATH)
-        } else if Path::new(FAN_TYPE_2_PATH).exists() {
-            Ok(FAN_TYPE_2_PATH)
-        } else {
-            Err(RogError::MissingFunction(
-                "Fan mode not available, you may require a v5.8.10 series kernel or newer".into(),
-            ))
-        }
-    }
-
-    /// Toggle to next profile in list
-    pub(super) fn do_next_profile(&mut self, config: &mut Config) -> Result<(), RogError> {
-        config.read();
-
-        let mut i = config
-            .toggle_profiles
-            .iter()
-            .position(|x| x == &config.active_profile)
-            .map(|i| i + 1)
-            .unwrap_or(0);
-        if i >= config.toggle_profiles.len() {
-            i = 0;
-        }
-
-        let new_profile = config
-            .toggle_profiles
-            .get(i)
-            .unwrap_or(&config.active_profile)
-            .clone();
-
-        self.set(&new_profile, config)?;
-
-        info!("Profile was changed: {}", &new_profile);
-        Ok(())
-    }
-
-    fn set_fan_mode(&mut self, preset: u8, config: &mut Config) -> Result<(), RogError> {
-        let mode = config.active_profile.clone();
-        let mut fan_ctrl = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        config.read();
-        let mut mode_config = config
-            .power_profiles
-            .get_mut(&mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.clone()))?;
-        config.curr_fan_mode = preset;
-        mode_config.fan_preset = preset;
-        config.write();
-        fan_ctrl
-            .write_all(format!("{}\n", preset).as_bytes())
-            .map_err(|err| RogError::Write(self.path.into(), err))?;
-        info!("Fan mode set to: {:?}", FanLevel::from(preset));
-        Ok(())
-    }
-
-    fn handle_profile_event(
-        &mut self,
-        event: &ProfileEvent,
-        config: &mut Config,
-    ) -> Result<(), RogError> {
-        match event {
-            ProfileEvent::Toggle => self.do_next_profile(config)?,
-            ProfileEvent::ChangeMode(mode) => {
-                self.set_fan_mode(*mode, config)?;
-                let mode = config.active_profile.clone();
-                self.set_pstate_for_fan_mode(&mode, config)?;
-                self.set_fan_curve_for_fan_mode(&mode, config)?;
-            }
-            ProfileEvent::Cli(command) => {
-                let profile_key = match command.profile.as_ref() {
-                    Some(k) => k.clone(),
-                    None => config.active_profile.clone(),
-                };
-
-                let mut profile = if command.create {
-                    config
-                        .power_profiles
-                        .entry(profile_key.clone())
-                        .or_insert_with(Profile::default)
-                } else {
-                    config
-                        .power_profiles
-                        .get_mut(&profile_key)
-                        .ok_or_else(|| RogError::MissingProfile(profile_key.clone()))?
-                };
-
-                if command.turbo.is_some() {
-                    profile.turbo = command.turbo.unwrap();
-                }
-                if let Some(min_perc) = command.min_percentage {
-                    profile.min_percentage = min_perc;
-                }
-                if let Some(max_perc) = command.max_percentage {
-                    profile.max_percentage = max_perc;
-                }
-                if let Some(ref preset) = command.fan_preset {
-                    profile.fan_preset = preset.into();
-                }
-                if let Some(ref curve) = command.curve {
-                    profile.fan_curve = Some(curve.clone());
-                }
-
-                self.set(&profile_key, config)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn set(&mut self, profile: &str, config: &mut Config) -> Result<(), RogError> {
-        let mode_config = config
-            .power_profiles
-            .get(profile)
-            .ok_or_else(|| RogError::MissingProfile(profile.into()))?;
-        let mut fan_ctrl = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        config.curr_fan_mode = mode_config.fan_preset;
-        fan_ctrl
-            .write_all(format!("{}\n", mode_config.fan_preset).as_bytes())
-            .map_err(|err| RogError::Write(self.path.into(), err))?;
-
-        self.set_pstate_for_fan_mode(profile, config)?;
-        self.set_fan_curve_for_fan_mode(profile, config)?;
-
-        config.active_profile = profile.into();
-
-        config.write();
-        Ok(())
-    }
-
-    fn set_pstate_for_fan_mode(&self, mode: &str, config: &mut Config) -> Result<(), RogError> {
-        info!("Setting pstate");
-        let mode_config = config
-            .power_profiles
-            .get(mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
-
-        // Set CPU pstate
-        if let Ok(pstate) = intel_pstate::PState::new() {
-            pstate.set_min_perf_pct(mode_config.min_percentage)?;
-            pstate.set_max_perf_pct(mode_config.max_percentage)?;
-            pstate.set_no_turbo(!mode_config.turbo)?;
-            info!(
-                "Intel CPU Power: min: {}%, max: {}%, turbo: {}",
-                mode_config.min_percentage, mode_config.max_percentage, mode_config.turbo
-            );
-        } else {
-            info!("Setting pstate for AMD CPU");
-            // must be AMD CPU
-            let mut file = OpenOptions::new()
-                .write(true)
-                .open(AMD_BOOST_PATH)
-                .map_err(|err| RogError::Path(self.path.into(), err))?;
-
-            let boost = if mode_config.turbo { "1" } else { "0" }; // opposite of Intel
-            file.write_all(boost.as_bytes())
-                .map_err(|err| RogError::Write(AMD_BOOST_PATH.into(), err))?;
-            info!("AMD CPU Turbo: {}", boost);
-        }
-        Ok(())
-    }
-
-    fn set_fan_curve_for_fan_mode(&self, mode: &str, config: &Config) -> Result<(), RogError> {
-        let mode_config = &config
-            .power_profiles
-            .get(mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
-
-        if let Some(ref curve) = mode_config.fan_curve {
-            use rog_fan_curve::{Board, Fan};
-            if let Some(board) = Board::from_board_name() {
-                curve.apply(board, Fan::Cpu)?;
-                curve.apply(board, Fan::Gpu)?;
-            } else {
-                warn!("Fan curve unsupported on this board.")
-            }
-        }
-
-        Ok(())
-    }
-}

daemon/src/ctrl_gfx/error.rs

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

daemon/src/ctrl_gfx/gfx.rs

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

daemon/src/ctrl_gfx/mod.rs

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

daemon/src/ctrl_gfx/system.rs

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

daemon/src/ctrl_leds.rs

@@ -1,451 +0,0 @@
-// Only these two packets must be 17 bytes
-static LED_APPLY: [u8; 17] = [0x5d, 0xb4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-static LED_SET: [u8; 17] = [0x5d, 0xb5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
-
-use crate::{
-    config_aura::AuraConfig,
-    error::RogError,
-    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-};
-use log::{error, info, warn};
-use rog_types::{LED_MSG_LEN, aura_modes::{AuraEffect, AuraModeNum, LedBrightness}, supported::LedSupportedFunctions};
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-use crate::GetSupported;
-
-impl GetSupported for CtrlKbdBacklight {
-    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 = if laptop.standard.is_empty() {
-            None
-        } else {
-            Some(laptop.standard)
-        };
-
-        LedSupportedFunctions {
-            brightness_set: CtrlKbdBacklight::get_kbd_bright_path().is_some(),
-            stock_led_modes,
-            multizone_led_mode,
-            per_key_led_mode,
-        }
-    }
-}
-
-pub struct CtrlKbdBacklight {
-    led_node: Option<String>,
-    pub bright_node: String,
-    supported_modes: LaptopLedData,
-    flip_effect_write: bool,
-    config: AuraConfig,
-}
-
-pub struct DbusKbdBacklight {
-    inner: Arc<Mutex<CtrlKbdBacklight>>,
-}
-
-impl DbusKbdBacklight {
-    pub fn new(inner: Arc<Mutex<CtrlKbdBacklight>>) -> Self {
-        Self { inner }
-    }
-}
-
-impl crate::ZbusAdd for DbusKbdBacklight {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&ObjectPath::from_str_unchecked("/org/asuslinux/Led"), self)
-            .map_err(|err| {
-                error!("DbusKbdBacklight: 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 DbusKbdBacklight {
-    fn set_brightness(&mut self, brightness: LedBrightness) {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            ctrl.set_brightness(brightness)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-        }
-    }
-
-    fn set_led_mode(&mut self, effect: AuraEffect) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            let mode_name = effect.mode_name();
-            match ctrl.do_command(effect) {
-                Ok(_) => {
-                    self.notify_led(&mode_name).ok();
-                }
-                Err(err) => {
-                    warn!("{}", err);
-                }
-            }
-        }
-    }
-
-    fn next_led_mode(&self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.toggle_mode(false)
-                .unwrap_or_else(|err| warn!("{}", err));
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                if let Ok(json) = serde_json::to_string(&mode) {
-                    self.notify_led(&json)
-                        .unwrap_or_else(|err| warn!("{}", err));
-                }
-            }
-        }
-    }
-
-    fn prev_led_mode(&self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.toggle_mode(true)
-                .unwrap_or_else(|err| warn!("{}", err));
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                if let Ok(json) = serde_json::to_string(&mode) {
-                    self.notify_led(&json)
-                        .unwrap_or_else(|err| warn!("{}", err));
-                }
-            }
-        }
-    }
-
-    /// Return the current mode data
-    #[dbus_interface(property)]
-    fn led_mode(&self) -> String {
-        if let Ok(ctrl) = self.inner.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.inner.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.inner.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: &str) -> zbus::Result<()>;
-}
-
-impl crate::Reloadable for CtrlKbdBacklight {
-    fn reload(&mut self) -> Result<(), RogError> {
-        // set current mode (if any)
-        if self.supported_modes.standard.len() > 1 {
-            let current_mode = self.config.current_mode;
-            if self.supported_modes.standard.contains(&(current_mode)) {
-                let mode = self
-                    .config
-                    .builtins
-                    .get(&current_mode)
-                    .ok_or(RogError::NotSupported)?
-                    .to_owned();
-                self.write_mode(&mode)?;
-                info!("Reloaded last used mode");
-            } else {
-                warn!(
-                    "An unsupported mode was set: {}, reset to first mode available",
-                    <&str>::from(&self.config.current_mode)
-                );
-                self.config.builtins.remove(&current_mode);
-                self.config.current_mode = AuraModeNum::Static;
-                // TODO: do a recursive call with a boxed dyn future later
-                let mode = self
-                    .config
-                    .builtins
-                    .get(&current_mode)
-                    .ok_or(RogError::NotSupported)?
-                    .to_owned();
-                self.write_mode(&mode)?;
-                info!("Reloaded last used mode");
-            }
-        }
-
-        // Reload brightness
-        let bright = self.config.brightness;
-        self.set_brightness(bright)?;
-        info!("Reloaded last used brightness");
-        Ok(())
-    }
-}
-
-impl crate::CtrlTask for CtrlKbdBacklight {
-    fn do_task(&mut self) -> Result<(), 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))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if self.config.brightness != num.into() {
-                self.config.read();
-                self.config.brightness = num.into();
-                self.config.write();
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLed)
-    }
-}
-
-impl CtrlKbdBacklight {
-    #[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 = CtrlKbdBacklight {
-            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 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 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(())
-    }
-
-    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]
-    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_platform.rs

@@ -0,0 +1,382 @@
+use crate::{config::Config, error::RogError, GetSupported};
+use crate::{task_watch_item, CtrlTask};
+use async_trait::async_trait;
+use log::{info, warn};
+use rog_platform::platform::{AsusPlatform, GpuMode};
+use rog_platform::supported::RogBiosSupportedFunctions;
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::Path;
+use std::process::Command;
+use std::sync::Arc;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::Connection;
+use zbus::{dbus_interface, SignalContext};
+
+const ZBUS_PATH: &str = "/org/asuslinux/Platform";
+const ASUS_POST_LOGO_SOUND: &str =
+    "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
+
+#[derive(Clone)]
+pub struct CtrlPlatform {
+    platform: AsusPlatform,
+    config: Arc<Mutex<Config>>,
+}
+
+impl GetSupported for CtrlPlatform {
+    type A = RogBiosSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        let mut panel_overdrive = false;
+        let mut dgpu_disable = false;
+        let mut egpu_enable = false;
+        let mut gpu_mux = false;
+
+        if let Ok(platform) = AsusPlatform::new() {
+            panel_overdrive = platform.has_panel_od();
+            dgpu_disable = platform.has_dgpu_disable();
+            egpu_enable = platform.has_egpu_enable();
+            gpu_mux = platform.has_gpu_mux_mode();
+        }
+
+        RogBiosSupportedFunctions {
+            post_sound: Path::new(ASUS_POST_LOGO_SOUND).exists(),
+            gpu_mux,
+            panel_overdrive,
+            dgpu_disable,
+            egpu_enable,
+        }
+    }
+}
+
+impl CtrlPlatform {
+    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
+        let platform = AsusPlatform::new()?;
+
+        if !platform.has_gpu_mux_mode() {
+            info!("G-Sync Switchable Graphics or GPU MUX not detected");
+            info!("Standard graphics switching will still work.");
+        }
+
+        if Path::new(ASUS_POST_LOGO_SOUND).exists() {
+            CtrlPlatform::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
+        } else {
+            info!("Switch for POST boot sound not detected");
+        }
+
+        Ok(CtrlPlatform { platform, 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(())
+    }
+
+    fn set_gfx_mode(&self, mode: GpuMode) -> Result<(), RogError> {
+        self.platform.set_gpu_mux_mode(mode.to_mux_attr())?;
+        // self.update_initramfs(enable)?;
+        if mode == GpuMode::Discrete {
+            info!("Set system-level graphics mode: Dedicated Nvidia");
+        } else {
+            info!("Set system-level graphics mode: Optimus");
+        }
+        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(())
+    }
+
+    fn set_panel_overdrive(&self, enable: bool) -> Result<(), RogError> {
+        self.platform.set_panel_od(enable).map_err(|err| {
+            warn!("CtrlRogBios: set_panel_overdrive {}", err);
+            err
+        })?;
+        Ok(())
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlPlatform {
+    async fn set_gpu_mux_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        mode: GpuMode,
+    ) {
+        self.set_gfx_mode(mode)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_gpu_mux_mode {}", err);
+                err
+            })
+            .ok();
+        Self::notify_gpu_mux_mode(&ctxt, mode).await.ok();
+    }
+
+    fn gpu_mux_mode(&self) -> GpuMode {
+        match self.platform.get_gpu_mux_mode() {
+            Ok(m) => GpuMode::from_mux(m as u8),
+            Err(e) => {
+                warn!("CtrlRogBios: get_gfx_mode {}", e);
+                GpuMode::Error
+            }
+        }
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_gpu_mux_mode(
+        signal_ctxt: &SignalContext<'_>,
+        mode: GpuMode,
+    ) -> zbus::Result<()> {
+    }
+
+    async fn set_post_boot_sound(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        on: bool,
+    ) {
+        Self::set_boot_sound(on)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_post_boot_sound {}", err);
+                err
+            })
+            .ok();
+        Self::notify_post_boot_sound(&ctxt, on).await.ok();
+    }
+
+    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)]
+    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
+
+    async fn set_panel_od(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        overdrive: bool,
+    ) {
+        match self.platform.set_panel_od(overdrive) {
+            Ok(_) => {
+                if let Some(mut lock) = self.config.try_lock() {
+                    lock.panel_od = overdrive;
+                    lock.write();
+                }
+                Self::notify_panel_od(&ctxt, overdrive).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_panel_overdrive {}", err),
+        };
+    }
+
+    /// Get the `panel_od` value from platform. Updates the stored value in internal config also.
+    fn panel_od(&self) -> bool {
+        let od = self
+            .platform
+            .get_panel_od()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_panel_od {}", err);
+                err
+            })
+            .unwrap_or(false);
+        if let Some(mut lock) = self.config.try_lock() {
+            lock.panel_od = od;
+            lock.write();
+        }
+        od
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
+    }
+
+    async fn set_dgpu_disable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        disable: bool,
+    ) {
+        match self.platform.set_dgpu_disable(disable) {
+            Ok(_) => {
+                Self::notify_dgpu_disable(&ctxt, disable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_dgpu_disable {}", err),
+        };
+    }
+
+    fn dgpu_disable(&self) -> bool {
+        self.platform
+            .get_dgpu_disable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_dgpu_disable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_dgpu_disable(
+        signal_ctxt: &SignalContext<'_>,
+        disable: bool,
+    ) -> zbus::Result<()> {
+    }
+
+    async fn set_egpu_enable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enable: bool,
+    ) {
+        match self.platform.set_egpu_enable(enable) {
+            Ok(_) => {
+                Self::notify_egpu_enable(&ctxt, enable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_egpu_enable {}", err),
+        };
+    }
+
+    fn egpu_enable(&self) -> bool {
+        self.platform
+            .get_egpu_enable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_egpu_enable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlPlatform {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Platform", server).await;
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlPlatform {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if self.platform.has_panel_od() {
+            let p = if let Some(lock) = self.config.try_lock() {
+                lock.panel_od
+            } else {
+                false
+            };
+            self.set_panel_overdrive(p)?;
+        }
+        Ok(())
+    }
+}
+
+impl CtrlPlatform {
+    task_watch_item!(panel_od platform);
+    task_watch_item!(dgpu_disable platform);
+    task_watch_item!(egpu_enable platform);
+    // NOTE: see note further below
+    //task_watch_item!(gpu_mux_mode platform);
+}
+
+#[async_trait]
+impl CtrlTask for CtrlPlatform {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let platform1 = self.clone();
+        let platform2 = self.clone();
+        self.create_sys_event_tasks(
+            move || async { {} },
+            move || {
+                let platform1 = platform1.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform1.config.lock().await;
+                    if platform1.platform.has_panel_od() {
+                        platform1
+                            .set_panel_overdrive(lock.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: set_limit {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move || async { {} },
+            move || {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform2.config.lock().await;
+                    if platform2.platform.has_panel_od() {
+                        platform2
+                            .set_panel_overdrive(lock.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: set_limit {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        self.watch_panel_od(signal_ctxt.clone()).await?;
+        self.watch_dgpu_disable(signal_ctxt.clone()).await?;
+        self.watch_egpu_enable(signal_ctxt.clone()).await?;
+        // NOTE: Can't have this as a watch because on a write to it, it reverts back to booted-with value
+        //  as it does not actually change until reboot.
+        //self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+
+        Ok(())
+    }
+}

daemon/src/ctrl_power.rs

@@ -0,0 +1,267 @@
+use crate::systemd::{
+    do_systemd_unit_action, is_systemd_unit_enabled, SystemdUnitAction, SystemdUnitState,
+};
+use crate::{config::Config, error::RogError, GetSupported};
+use crate::{task_watch_item, CtrlTask};
+use async_trait::async_trait;
+use log::{error, info, warn};
+use rog_platform::power::AsusPower;
+use rog_platform::supported::ChargeSupportedFunctions;
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
+use zbus::dbus_interface;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::Connection;
+use zbus::SignalContext;
+
+const ZBUS_PATH: &str = "/org/asuslinux/Power";
+const NVIDIA_POWERD: &str = "nvidia-powerd.service";
+
+impl GetSupported for CtrlPower {
+    type A = ChargeSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        ChargeSupportedFunctions {
+            charge_level_set: if let Ok(power) = AsusPower::new() {
+                power.has_charge_control_end_threshold()
+            } else {
+                false
+            },
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct CtrlPower {
+    power: AsusPower,
+    config: Arc<Mutex<Config>>,
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlPower {
+    async fn set_charge_control_end_threshold(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        limit: u8,
+    ) -> zbus::fdo::Result<()> {
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit))?;
+        }
+        self.set(limit)
+            .map_err(|err| {
+                warn!("CtrlCharge: set_limit {}", err);
+                err
+            })
+            .ok();
+        Self::notify_charge_control_end_threshold(&ctxt, limit)
+            .await
+            .ok();
+        Ok(())
+    }
+
+    fn charge_control_end_threshold(&self) -> u8 {
+        loop {
+            if let Some(mut config) = self.config.try_lock() {
+                let limit = self
+                    .power
+                    .get_charge_control_end_threshold()
+                    .map_err(|err| {
+                        warn!("CtrlCharge: get_charge_control_end_threshold {}", err);
+                        err
+                    })
+                    .unwrap_or(100);
+
+                config.read();
+                config.bat_charge_limit = limit;
+                config.write();
+
+                return config.bat_charge_limit;
+            }
+        }
+    }
+
+    fn mains_online(&self) -> bool {
+        if self.power.has_online() {
+            if let Ok(v) = self.power.get_online() {
+                return v == 1;
+            }
+        }
+        false
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_charge_control_end_threshold(
+        ctxt: &SignalContext<'_>,
+        limit: u8,
+    ) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_mains_online(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlPower {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlPower {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(mut config) = self.config.try_lock() {
+            config.read();
+            self.set(config.bat_charge_limit)?;
+        }
+        Ok(())
+    }
+}
+
+impl CtrlPower {
+    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
+        Ok(CtrlPower {
+            power: AsusPower::new()?,
+            config,
+        })
+    }
+
+    pub(super) fn set(&self, limit: u8) -> Result<(), RogError> {
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit));
+        }
+
+        self.power.set_charge_control_end_threshold(limit)?;
+
+        info!("Battery charge limit: {}", limit);
+
+        if let Some(mut config) = self.config.try_lock() {
+            config.read();
+            config.bat_charge_limit = limit;
+            config.write();
+        }
+
+        Ok(())
+    }
+
+    task_watch_item!(charge_control_end_threshold power);
+}
+
+#[async_trait]
+impl CtrlTask for CtrlPower {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let power1 = self.clone();
+        let power2 = self.clone();
+        self.create_sys_event_tasks(
+            move || async {},
+            move || {
+                let power1 = power1.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power1.config.lock().await;
+                    power1
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+
+                    if let Ok(value) = power1.power.get_online() {
+                        do_nvidia_powerd_action(value == 1);
+                    }
+                }
+            },
+            move || async {},
+            move || {
+                let power2 = power2.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power2.config.lock().await;
+                    power2
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+
+                    if let Ok(value) = power2.power.get_online() {
+                        do_nvidia_powerd_action(value == 1);
+                    }
+                }
+            },
+        )
+        .await;
+
+        let config = self.config.clone();
+        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+            .await?;
+
+        let ctrl = self.clone();
+        tokio::spawn(async move {
+            let mut online = 10;
+            loop {
+                if let Ok(value) = ctrl.power.get_online() {
+                    if online != value {
+                        online = value;
+                        do_nvidia_powerd_action(value == 1);
+
+                        Self::notify_mains_online(&signal_ctxt, value == 1)
+                            .await
+                            .unwrap();
+
+                        let mut config = config.lock().await;
+                        config.read();
+                        let mut prog: Vec<&str> = Vec::new();
+                        if value == 1 {
+                            // AC ONLINE
+                            prog = config.ac_command.split_whitespace().collect();
+                        } else if value == 0 {
+                            // BATTERY
+                            prog = config.bat_command.split_whitespace().collect();
+                        }
+
+                        if prog.len() > 1 {
+                            let mut cmd = Command::new(prog[0]);
+                            for arg in prog.iter().skip(1) {
+                                cmd.arg(*arg);
+                            }
+                            if let Err(e) = cmd.spawn() {
+                                if value == 1 {
+                                    error!("AC power command error: {e}");
+                                } else {
+                                    error!("Battery power command error: {e}");
+                                }
+                            }
+                        }
+                    }
+                }
+                // The inotify doesn't pick up events when the kernel changes internal value
+                // so we need to watch it with a thread and sleep unfortunately
+                sleep(Duration::from_secs(1)).await;
+            }
+        });
+
+        Ok(())
+    }
+}
+
+fn do_nvidia_powerd_action(ac_on: bool) {
+    let action = if ac_on {
+        SystemdUnitAction::Restart
+    } else {
+        SystemdUnitAction::Stop
+    };
+
+    if let Ok(res) = is_systemd_unit_enabled(SystemdUnitState::Enabled, NVIDIA_POWERD) {
+        if res && do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+            info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+        }
+    }
+}

daemon/src/ctrl_profiles/config.rs

@@ -0,0 +1,88 @@
+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 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);
+            } 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 mut cfg_old = config_path.clone();
+                cfg_old.push_str("-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);
+            }
+        } else {
+            config = Self::new(config_path);
+        }
+        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

@@ -0,0 +1,116 @@
+use crate::error::RogError;
+use crate::GetSupported;
+use log::{info, warn};
+use rog_platform::platform::AsusPlatform;
+use rog_platform::supported::PlatformProfileFunctions;
+use rog_profiles::error::ProfileError;
+use rog_profiles::{FanCurveProfiles, Profile};
+
+use super::config::ProfileConfig;
+
+pub struct CtrlPlatformProfile {
+    pub config: ProfileConfig,
+    pub platform: AsusPlatform,
+}
+
+impl GetSupported for CtrlPlatformProfile {
+    type A = PlatformProfileFunctions;
+
+    fn get_supported() -> Self::A {
+        if !Profile::is_platform_profile_supported() {
+            warn!("platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.");
+        }
+
+        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!("fan curves kernel interface not found, your laptop does not support this, or the interface is missing.");
+        }
+
+        PlatformProfileFunctions {
+            platform_profile: Profile::is_platform_profile_supported(),
+            fan_curves: fan_curve_supported,
+        }
+    }
+}
+
+impl CtrlPlatformProfile {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
+        let platform = AsusPlatform::new()?;
+        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
+            info!("Device has profile control available");
+
+            let mut controller = CtrlPlatformProfile { config, platform };
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("Device has fan curves available");
+                if controller.config.fan_curves.is_none() {
+                    controller.config.fan_curves = Some(Default::default());
+                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
+                        controller.set_next_profile()?;
+                        controller.set_active_curve_to_defaults()?;
+
+                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+                        if let Some(curves) = controller.config.fan_curves.as_ref() {
+                            info!(
+                                "{active:?}: {}",
+                                String::from(curves.get_fan_curves_for(active))
+                            );
+                        }
+                    }
+                }
+            }
+
+            return Ok(controller);
+        }
+
+        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(())
+    }
+}

daemon/src/ctrl_profiles/mod.rs

@@ -0,0 +1,4 @@
+pub mod config;
+pub mod controller;
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
+pub mod trait_impls;

daemon/src/ctrl_profiles/trait_impls.rs

@@ -0,0 +1,276 @@
+use async_trait::async_trait;
+use log::warn;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::fan_curve_set::FanCurveSet;
+use rog_profiles::FanCurveProfiles;
+use rog_profiles::Profile;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::export::futures_util::StreamExt;
+use zbus::Connection;
+use zbus::SignalContext;
+
+use std::sync::Arc;
+use zbus::{dbus_interface, fdo::Error};
+
+use crate::error::RogError;
+use crate::CtrlTask;
+
+use super::controller::CtrlPlatformProfile;
+
+const ZBUS_PATH: &str = "/org/asuslinux/Profile";
+const UNSUPPORTED_MSG: &str =
+    "Fan curves are not supported on this laptop or you require a patched kernel";
+
+#[derive(Clone)]
+pub struct ProfileZbus(pub Arc<Mutex<CtrlPlatformProfile>>);
+
+#[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_owned(),
+        ))
+    }
+
+    /// Toggle to next platform_profile. Names provided by `Profiles`.
+    /// If fan-curves are supported will also activate a fan curve for profile.
+    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut ctrl = self.0.lock().await;
+        ctrl.set_next_profile()
+            .unwrap_or_else(|err| warn!("{}", err));
+        ctrl.save_config();
+
+        Self::notify_profile(&ctxt, ctrl.config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Fetch the active profile name
+    async fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        Ok(ctrl.config.active_profile)
+    }
+
+    /// Set this platform_profile name as active
+    async fn set_active_profile(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        profile: Profile,
+    ) {
+        let mut ctrl = self.0.lock().await;
+        // 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::notify_profile(&ctxt, ctrl.config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Get a list of profiles that have fan-curves enabled.
+    async fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &ctrl.config.fan_curves {
+            return Ok(curves.get_enabled_curve_profiles());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
+    }
+
+    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
+    /// same profile mode
+    async fn set_fan_curve_enabled(
+        &mut self,
+        profile: Profile,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        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_owned()))
+        }
+    }
+
+    /// Get the fan-curve data for the currently active Profile
+    async fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &ctrl.config.fan_curves {
+            let curve = curves.get_fan_curves_for(profile);
+            return Ok(curve.clone());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
+    }
+
+    /// 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(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        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_owned()));
+        }
+        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.
+    async fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        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(())
+    }
+
+    /// 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: Profile) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+        Profile::set_profile(profile)
+            .map_err(|e| warn!("set_profile, {}", e))
+            .ok();
+        ctrl.set_active_curve_to_defaults()
+            .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
+            .ok();
+
+        Profile::set_profile(active)
+            .map_err(|e| warn!("set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+        Ok(())
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for ProfileZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl CtrlTask for ProfileZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        // let ctrl = self.0.clone();
+        // let mut watch = self.0.lock().await.platform.monitor_platform_profile()?;
+        // let sig_ctx = signal_ctxt.clone();
+        // tokio::spawn(async move {
+        //     let mut buffer = [0; 32];
+        //     watch
+        //         .event_stream(&mut buffer)
+        //         .unwrap()
+        //         .for_each(|_| async {
+        //             let mut lock = ctrl.lock().await;
+        //             let new_profile = Profile::get_active_profile().unwrap();
+        //             if new_profile != lock.config.active_profile {
+        //                 lock.config.active_profile = new_profile;
+        //                 lock.write_profile_curve_to_platform().unwrap();
+        //                 lock.save_config();
+        //             }
+        //             Self::notify_profile(&sig_ctx, lock.config.active_profile)
+        //                 .await
+        //                 .ok();
+        //         })
+        //         .await;
+        // });
+
+        let ctrl = self.0.clone();
+        let mut watch = self
+            .0
+            .lock()
+            .await
+            .platform
+            .monitor_throttle_thermal_policy()?;
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    let mut lock = ctrl.lock().await;
+                    let new_thermal = lock.platform.get_throttle_thermal_policy().unwrap();
+                    let new_profile = Profile::from_throttle_thermal_policy(new_thermal);
+                    if new_profile != lock.config.active_profile {
+                        lock.config.active_profile = new_profile;
+                        lock.write_profile_curve_to_platform().unwrap();
+                        lock.save_config();
+                        Profile::set_profile(lock.config.active_profile).unwrap();
+                    }
+                    Self::notify_profile(&signal_ctxt, lock.config.active_profile)
+                        .await
+                        .ok();
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for ProfileZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        let active = ctrl.config.active_profile;
+        if let Some(curves) = &mut ctrl.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(active, &mut device)?;
+                ctrl.config.write();
+            }
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_rog_bios.rs

@@ -1,342 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-use log::{error, info, warn};
-use rog_types::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: CtrlRogBios::check_path_exists(ASUS_POST_LOGO_SOUND).is_ok(),
-            dedicated_gfx_toggle: CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE).is_ok(),
-        }
-    }
-}
-
-#[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> {
-        match CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE) {
-            Ok(_) => {
-                CtrlRogBios::set_path_mutable(ASUS_SWITCH_GRAPHIC_MODE)?;
-            }
-            Err(err) => {
-                info!("ROG Switchable Graphics (bios) not detected: {}", err);
-            }
-        }
-
-        match CtrlRogBios::check_path_exists(ASUS_POST_LOGO_SOUND) {
-            Ok(_) => {
-                CtrlRogBios::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
-            }
-            Err(err) => {
-                info!("ROG boot sound toggle (bios) not detected: {}", err);
-            }
-        }
-
-        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(())
-    }
-
-    fn check_path_exists(path: &str) -> Result<(), RogError> {
-        if Path::new(path).exists() {
-            Ok(())
-        } else {
-            Err(RogError::MissingFunction(path.into()))
-        }
-    }
-
-    pub fn has_dedicated_gfx_toggle() -> bool {
-        if CtrlRogBios::check_path_exists(ASUS_SWITCH_GRAPHIC_MODE).is_ok() {
-            return true;
-        }
-        false
-    }
-
-    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).unwrap();
-
-        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)?;
-
-        // if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
-        //     if let Ok(vendor) = CtrlGraphics::get_vendor() {
-        //         if ded == 1 && vendor != "nvidia" {
-        //             warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
-        //             CtrlGraphics::set_gfx_config(&GfxVendors::Nvidia)
-        //                 .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
-        //         }
-        //     }
-        // }
-
-        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()).unwrap();
-                } 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() {
-                        if let Ok(l) = line {
-                            if !modules.contains(&l.as_ref()) {
-                                buf.append(&mut l.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).unwrap();
-                }
-            }
-
-            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,46 +1,34 @@
-use log::warn;
+use async_trait::async_trait;
 use serde_derive::{Deserialize, Serialize};
-use zbus::dbus_interface;
+use zbus::{dbus_interface, zvariant::Type, Connection};
-use zvariant::ObjectPath;
 
 use crate::{
-    ctrl_anime::CtrlAnimeDisplay, ctrl_charge::CtrlCharge, ctrl_fan_cpu::CtrlFanAndCpu,
+    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_platform::CtrlPlatform,
-    ctrl_leds::CtrlKbdBacklight, ctrl_rog_bios::CtrlRogBios, GetSupported,
+    ctrl_power::CtrlPower, ctrl_profiles::controller::CtrlPlatformProfile, GetSupported,
 };
 
-use rog_types::supported::{
+use rog_platform::supported::*;
-    AnimeSupportedFunctions, ChargeSupportedFunctions, FanCpuSupportedFunctions,
-    LedSupportedFunctions, RogBiosSupportedFunctions,
-};
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Type)]
 pub struct SupportedFunctions {
     pub anime_ctrl: AnimeSupportedFunctions,
     pub charge_ctrl: ChargeSupportedFunctions,
-    pub fan_cpu_ctrl: FanCpuSupportedFunctions,
+    pub platform_profile: PlatformProfileFunctions,
     pub keyboard_led: LedSupportedFunctions,
     pub rog_bios_ctrl: RogBiosSupportedFunctions,
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl SupportedFunctions {
-    fn supported_functions(&self) -> String {
+    fn supported_functions(&self) -> &SupportedFunctions {
-        serde_json::to_string_pretty(self).unwrap()
+        self
     }
 }
 
-impl crate::ZbusAdd for SupportedFunctions {
+#[async_trait]
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+impl crate::ZbusRun for SupportedFunctions {
-        server
+    async fn add_to_server(self, server: &mut Connection) {
-            .at(
+        Self::add_to_server_helper(self, "/org/asuslinux/Supported", server).await;
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Supported"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("SupportedFunctions: add_to_server {}", err);
-                err
-            })
-            .ok();
     }
 }
 
@@ -49,11 +37,11 @@ impl GetSupported for SupportedFunctions {
 
     fn get_supported() -> Self::A {
         SupportedFunctions {
-            keyboard_led: CtrlKbdBacklight::get_supported(),
+            anime_ctrl: CtrlAnime::get_supported(),
-            anime_ctrl: CtrlAnimeDisplay::get_supported(),
+            keyboard_led: CtrlKbdLed::get_supported(),
-            charge_ctrl: CtrlCharge::get_supported(),
+            charge_ctrl: CtrlPower::get_supported(),
-            fan_cpu_ctrl: CtrlFanAndCpu::get_supported(),
+            platform_profile: CtrlPlatformProfile::get_supported(),
-            rog_bios_ctrl: CtrlRogBios::get_supported(),
+            rog_bios_ctrl: CtrlPlatform::get_supported(),
         }
     }
 }

daemon/src/daemon.rs

@@ -1,198 +1,165 @@
-use daemon::ctrl_leds::{CtrlKbdBacklight, DbusKbdBacklight};
+use std::env;
-use daemon::{
-    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
-};
-use daemon::{config_aura::AuraConfig, ctrl_charge::CtrlCharge};
-use daemon::{ctrl_anime::CtrlAnimeDisplay, ctrl_gfx::gfx::CtrlGraphics};
-use daemon::{
-    ctrl_fan_cpu::{CtrlFanAndCpu, DbusFanAndCpu},
-    laptops::LaptopLedData,
-};
-
-use daemon::{CtrlTask, Reloadable, ZbusAdd};
-use log::LevelFilter;
-use log::{error, info, warn};
-use rog_dbus::DBUS_NAME;
-use rog_types::gfx_vendors::GfxVendors;
 use std::error::Error;
 use std::io::Write;
 use std::sync::Arc;
-use std::sync::Mutex;
+use std::time::Duration;
 
-use daemon::ctrl_rog_bios::CtrlRogBios;
+use ::zbus::export::futures_util::lock::Mutex;
-use std::convert::Into;
+use ::zbus::Connection;
-use zbus::fdo;
+use daemon::ctrl_anime::CtrlAnime;
-use zbus::Connection;
+use log::{error, info, warn};
-use zvariant::ObjectPath;
+use tokio::time::sleep;
+use zbus::SignalContext;
 
-pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+use daemon::ctrl_anime::{config::AnimeConfig, trait_impls::CtrlAnimeZbus};
+use daemon::ctrl_aura::{config::AuraConfig, controller::CtrlKbdLed, trait_impls::CtrlKbdLedZbus};
+use daemon::ctrl_platform::CtrlPlatform;
+use daemon::ctrl_power::CtrlPower;
+use daemon::ctrl_profiles::{
+    config::ProfileConfig, controller::CtrlPlatformProfile, trait_impls::ProfileZbus,
+};
+use daemon::laptops::LaptopLedData;
+use daemon::{
+    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
+};
+use daemon::{CtrlTask, Reloadable, ZbusRun};
+use rog_dbus::DBUS_NAME;
+use rog_profiles::Profile;
+
+static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
+
+#[tokio::main]
+async 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()))
-        .filter(None, LevelFilter::Info)
         .init();
 
-    info!("   daemon v{}", daemon::VERSION);
+    let is_service = match env::var_os("IS_SERVICE") {
-    info!(" rog-dbus v{}", rog_dbus::VERSION);
+        Some(val) => val == "1",
-    info!("rog-types v{}", rog_types::VERSION);
+        None => false,
+    };
 
-    start_daemon()?;
+    if !is_service {
+        println!("asusd schould be only run from the right systemd service");
+        println!(
+            "do not run in your terminal, if you need an logs please use journalctl -b -u asusd"
+        );
+        println!("asusd will now exit");
+        return Ok(());
+    }
+
+    info!("       daemon v{}", daemon::VERSION);
+    info!("    rog-anime v{}", rog_anime::VERSION);
+    info!("     rog-aura v{}", rog_aura::VERSION);
+    info!("     rog-dbus v{}", rog_dbus::VERSION);
+    info!(" rog-profiles v{}", rog_profiles::VERSION);
+    info!("rog-platform v{}", rog_platform::VERSION);
+
+    start_daemon().await?;
     Ok(())
 }
 
-// Timing is such that:
+/// The actual main loop for the daemon
-// - interrupt write is minimum 1ms (sometimes lower)
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
-// - read interrupt must timeout, minimum of 1ms
-// - for a single usb packet, 2ms total.
-// - to maintain constant times of 1ms, per-key colours should use
-//   the effect endpoint so that the complete colour block is written
-//   as fast as 1ms per row of the matrix inside it. (10ms total time)
-fn start_daemon() -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
-    println!("{}", serde_json::to_string_pretty(&supported).unwrap());
+    println!("{}", serde_json::to_string_pretty(&supported)?);
+
+    // Start zbus server
+    let mut connection = Connection::system().await?;
 
     let config = Config::load();
-    let enable_gfx_switching = config.gfx_managed;
     let config = Arc::new(Mutex::new(config));
 
-    let connection = Connection::new_system()?;
+    supported.add_to_server(&mut connection).await;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut object_server = zbus::ObjectServer::new(&connection);
 
-    supported.add_to_server(&mut object_server);
+    match CtrlPlatform::new(config.clone()) {
-
-    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.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!("charge_control: {}", err);
-        }
-    }
-
-    match CtrlAnimeDisplay::new() {
         Ok(ctrl) => {
-            ctrl.add_to_server(&mut object_server);
+            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("AniMe control: {}", err);
+            error!("CtrlPlatform: {}", err);
         }
     }
 
-    if enable_gfx_switching {
+    match CtrlPower::new(config.clone()) {
-        match CtrlGraphics::new(config.clone()) {
+        Ok(ctrl) => {
-            Ok(mut ctrl) => {
+            let sig_ctx = CtrlPower::signal_context(&connection)?;
-                // Need to check if a laptop has the dedicated gfx switch
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
-                if CtrlRogBios::has_dedicated_gfx_toggle() {
+        }
-                    if let Ok(ded) = CtrlRogBios::get_gfx_mode() {
+        Err(err) => {
-                        if let Ok(vendor) = ctrl.get_gfx_mode() {
+            error!("CtrlPower: {}", err);
-                            if ded == 1 && vendor != GfxVendors::Nvidia {
+        }
-                                warn!("Dedicated GFX toggle is on but driver mode is not nvidia \nSetting to nvidia driver mode");
+    }
-                                let devices = ctrl.devices();
+
-                                let bus = ctrl.bus();
+    if Profile::is_platform_profile_supported() {
-                                CtrlGraphics::do_vendor_tasks(
+        let profile_config = ProfileConfig::load(PROFILE_CONFIG_PATH.into());
-                                    GfxVendors::Nvidia,
+        match CtrlPlatformProfile::new(profile_config) {
-                                    false,
+            Ok(ctrl) => {
-                                    &devices,
+                let zbus = ProfileZbus(Arc::new(Mutex::new(ctrl)));
-                                    &bus,
+                let sig_ctx = ProfileZbus::signal_context(&connection)?;
-                                )?;
+                start_tasks(zbus, &mut connection, sig_ctx).await?;
-                            } else if ded == 0 {
-                                info!("Dedicated GFX toggle is off");
-                            }
-                        }
-                    }
-                }
-                ctrl.reload()
-                    .unwrap_or_else(|err| error!("Gfx controller: {}", err));
-                ctrl.add_to_server(&mut object_server);
             }
             Err(err) => {
-                error!("Gfx control: {}", err);
+                error!("Profile control: {}", err);
             }
         }
+    } else {
+        warn!("platform_profile support not found");
     }
 
-    // Collect tasks for task thread
+    match CtrlAnime::new(AnimeConfig::load()) {
-    let mut tasks: Vec<Arc<Mutex<dyn CtrlTask + Send>>> = Vec::new();
+        Ok(ctrl) => {
-
+            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
-    if let Ok(mut ctrl) = CtrlFanAndCpu::new(config).map_err(|err| {
+            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
-        error!("Profile control: {}", err);
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
-    }) {
+        }
-        ctrl.reload()
+        Err(err) => {
-            .unwrap_or_else(|err| warn!("Profile control: {}", err));
+            info!("AniMe control: {}", err);
-        let tmp = Arc::new(Mutex::new(ctrl));
+        }
-        DbusFanAndCpu::new(tmp).add_to_server(&mut object_server);
+    }
-    };
 
     let laptop = LaptopLedData::get_data();
     let aura_config = AuraConfig::load(&laptop);
-    if let Ok(ctrl) = CtrlKbdBacklight::new(laptop, aura_config).map_err(|err| {
+    match CtrlKbdLed::new(laptop, aura_config) {
-        error!("Keyboard control: {}", err);
+        Ok(ctrl) => {
-        err
+            let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
-    }) {
+            let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;
-        let tmp = Arc::new(Mutex::new(ctrl));
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
-        DbusKbdBacklight::new(tmp.clone()).add_to_server(&mut object_server);
+        }
-        tasks.push(tmp);
+        Err(err) => {
+            error!("Keyboard control: {}", err);
+        }
     }
 
-    // TODO: implement messaging between threads to check fails
+    // Request dbus name after finishing initalizing all functions
-    // These tasks generally read a sys path or file to check for a
+    connection.request_name(DBUS_NAME).await?;
-    // change
-    let handle = std::thread::Builder::new()
-        .name("asusd watch".to_string())
-        .spawn(move || loop {
-            std::thread::sleep(std::time::Duration::from_millis(100));
-
-            for ctrl in tasks.iter() {
-                if let Ok(mut lock) = ctrl.try_lock() {
-                    lock.do_task()
-                        .map_err(|err| {
-                            warn!("do_task error: {}", err);
-                        })
-                        .ok();
-                }
-            }
-        });
-
-    object_server
-        .with(
-            &ObjectPath::from_str_unchecked("/org/asuslinux/Charge"),
-            |obj: &CtrlCharge| {
-                let x = obj.limit();
-                obj.notify_charge(x as u8)
-            },
-        )
-        .map_err(|err| {
-            warn!("object_server notify_charge error: {}", err);
-        })
-        .ok();
 
     loop {
-        if let Err(err) = &handle {
+        // This is just a blocker to idle and ensure the reator reacts
-            error!("{}", err);
+        sleep(Duration::from_millis(1000)).await;
-        }
-        if let Err(err) = object_server.try_handle_next() {
-            error!("{}", err);
-        }
     }
 }
+
+async fn start_tasks<T>(
+    mut zbus: T,
+    connection: &mut Connection,
+    signal_ctx: SignalContext<'static>,
+) -> Result<(), Box<dyn Error>>
+where
+    T: ZbusRun + Reloadable + CtrlTask + Clone,
+{
+    let task = zbus.clone();
+
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    zbus.add_to_server(connection).await;
+
+    task.create_tasks(signal_ctx).await.ok();
+    Ok(())
+}

daemon/src/error.rs

@@ -1,14 +1,11 @@
-use intel_pstate::PStateError;
+use rog_anime::error::AnimeError;
-use rog_fan_curve::CurveError;
+use rog_platform::error::PlatformError;
-use rog_types::error::GraphicsError;
+use rog_profiles::error::ProfileError;
 use std::convert::From;
 use std::fmt;
 
-use crate::ctrl_gfx::error::GfxError;
-
 #[derive(Debug)]
 pub enum RogError {
-    ParseFanLevel,
     ParseVendor,
     ParseLed,
     MissingProfile(String),
@@ -18,25 +15,30 @@ pub enum RogError {
     Write(String, std::io::Error),
     NotSupported,
     NotFound(String),
-    IntelPstate(PStateError),
-    FanCurve(CurveError),
     DoTask(String),
     MissingFunction(String),
     MissingLedBrightNode(String, std::io::Error),
     ReloadFail(String),
-    GfxSwitching(GfxError),
+    Profiles(ProfileError),
     Initramfs(String),
     Modprobe(String),
-    Command(String, std::io::Error),
     Io(std::io::Error),
     Zbus(zbus::Error),
+    ChargeLimit(u8),
+    AuraEffectNotSupported,
+    NoAuraKeyboard,
+    NoAuraNode,
+    Anime(AnimeError),
+    Platform(PlatformError),
+    SystemdUnitAction(String),
+    SystemdUnitWaitTimeout(String),
+    Command(String, std::io::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::ParseFanLevel => write!(f, "Parse profile error"),
             RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
             RogError::ParseLed => write!(f, "Parse LED error"),
             RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
@@ -46,42 +48,53 @@ impl fmt::Display for RogError {
             RogError::Write(path, error) => write!(f, "Write {}: {}", path, error),
             RogError::NotSupported => write!(f, "Not supported"),
             RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
-            RogError::IntelPstate(err) => write!(f, "Intel pstate error: {}", err),
-            RogError::FanCurve(err) => write!(f, "Custom fan-curve error: {}", err),
             RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
             RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
             RogError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
-            RogError::ReloadFail(deets) => write!(f, "Task error: {}", deets),
+            RogError::ReloadFail(deets) => write!(f, "Reload error: {}", deets),
-            RogError::GfxSwitching(deets) => write!(f, "Graphics switching error: {}", deets),
+            RogError::Profiles(deets) => write!(f, "Profile error: {}", deets),
             RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
             RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
-            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
+            RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
+            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::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),
         }
     }
 }
 
 impl std::error::Error for RogError {}
 
-impl From<PStateError> for RogError {
+impl From<ProfileError> for RogError {
-    fn from(err: PStateError) -> Self {
+    fn from(err: ProfileError) -> Self {
-        RogError::IntelPstate(err)
+        RogError::Profiles(err)
     }
 }
 
-impl From<CurveError> for RogError {
+impl From<AnimeError> for RogError {
-    fn from(err: CurveError) -> Self {
+    fn from(err: AnimeError) -> Self {
-        RogError::FanCurve(err)
+        RogError::Anime(err)
     }
 }
 
-impl From<GraphicsError> for RogError {
+impl From<PlatformError> for RogError {
-    fn from(err: GraphicsError) -> Self {
+    fn from(err: PlatformError) -> Self {
-        match err {
+        RogError::Platform(err)
-            GraphicsError::ParseVendor => RogError::GfxSwitching(GfxError::ParseVendor),
-            GraphicsError::ParsePower => RogError::GfxSwitching(GfxError::ParsePower),
-        }
     }
 }
 
@@ -96,3 +109,10 @@ impl From<std::io::Error> for RogError {
         RogError::Io(err)
     }
 }
+
+impl From<RogError> for zbus::fdo::Error {
+    #[inline]
+    fn from(err: RogError) -> Self {
+        zbus::fdo::Error::Failed(format!("{}", err))
+    }
+}

daemon/src/laptops.rs

@@ -1,19 +1,18 @@
 use log::{info, warn};
-use rog_types::aura_modes::AuraModeNum;
+use rog_aura::{AuraModeNum, AuraZone};
 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_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd-user-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_name = dmi.product_name().expect("Could not get product_name");
     let prod_family = dmi.product_family().expect("Could not get product_family");
 
-    info!("Product name: {}", prod_name.trim());
     info!("Product family: {}", prod_family.trim());
     info!("Board name: {}", board_name.trim());
 }
@@ -34,17 +33,18 @@ pub fn print_modes(supported_modes: &[u8]) {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Default, Deserialize, Serialize)]
 struct LedSupportFile {
     led_data: Vec<LaptopLedData>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[serde(default)]
 pub struct LaptopLedData {
     pub prod_family: String,
     pub board_names: Vec<String>,
     pub standard: Vec<AuraModeNum>,
-    pub multizone: bool,
+    pub multizone: Vec<AuraZone>,
     pub per_key: bool,
 }
 
@@ -64,14 +64,14 @@ impl LaptopLedData {
             prod_family,
             board_names: vec![board_name],
             standard: vec![],
-            multizone: false,
+            multizone: vec![],
             per_key: false,
         }
     }
 }
 
 impl LedSupportFile {
-    /// Consumes the LEDModes
+    /// 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) {
@@ -87,19 +87,81 @@ impl LedSupportFile {
     }
 
     fn load_from_config() -> Option<Self> {
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_CONF) {
+        let mut loaded = false;
+        let mut data = LedSupportFile::default();
+        // Load user configs first so they are first to be checked
+        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_USER_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_USER_CONF);
+                } else {
+                    if let Ok(mut tmp) = toml::from_str::<LedSupportFile>(&buf) {
+                        data.led_data.append(&mut tmp.led_data);
+                    }
+                    info!(
+                        "Loaded user-defined LED support data from {}",
+                        ASUS_LED_MODE_USER_CONF
+                    );
+                }
+            }
+        }
+        // Load and append the default LED support data
+        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(|_| {
+                    let mut tmp: LedSupportFile = toml::from_str(&buf)
-                        panic!("Could not deserialise {}", ASUS_LED_MODE_CONF)
+                        .unwrap_or_else(|_| panic!("Could not deserialise {}", ASUS_LED_MODE_CONF));
-                    }));
+                    data.led_data.append(&mut tmp.led_data);
+                    loaded = true;
+                    info!(
+                        "Loaded default LED support data from {}",
+                        ASUS_LED_MODE_CONF
+                    );
                 }
             }
         }
-        warn!("Does {} exist?", ASUS_LED_MODE_CONF);
+
+        if loaded {
+            return Some(data);
+        }
+
+        warn!("Does {} exist?", ASUS_LED_MODE_USER_CONF);
         None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{fs::OpenOptions, io::Read, path::PathBuf};
+
+    use super::LaptopLedData;
+    use rog_aura::{AuraModeNum, AuraZone};
+
+    #[test]
+    fn check_data_parse() {
+        let led = LaptopLedData {
+            prod_family: "Test".to_owned(),
+            board_names: vec!["Test".to_owned()],
+            standard: vec![AuraModeNum::Static],
+            multizone: vec![AuraZone::Key1, AuraZone::Logo, AuraZone::BarLeft],
+            per_key: false,
+        };
+
+        let toml = toml::to_string_pretty(&led).unwrap();
+        println!("{toml}");
+
+        let mut data = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        data.push("../data/asusd-ledmodes.toml");
+
+        let mut file = OpenOptions::new().read(true).open(&data).unwrap();
+        let mut buf = String::new();
+        file.read_to_string(&mut buf).unwrap();
+
+        let x = toml::to_string_pretty(&buf).unwrap();
+        println!("{x}");
+    }
+}

daemon/src/lib.rs

@@ -1,60 +1,210 @@
 #![deny(unused_must_use)]
 /// Configuration loading, saving
 pub mod config;
-pub mod config_aura;
+/// Control of anime matrix display
-pub(crate) mod config_old;
-/// Control of AniMe matrix display
 pub mod ctrl_anime;
-/// 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_fan_cpu;
-/// GPU switching and power
-pub mod ctrl_gfx;
 /// Keyboard LED brightness control, RGB, and LED display modes
-pub mod ctrl_leds;
+pub mod ctrl_aura;
 /// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
-pub mod ctrl_rog_bios;
+pub mod ctrl_platform;
+/// Control of battery charge level
+pub mod ctrl_power;
+/// Control platform profiles + fan-curves if available
+pub mod ctrl_profiles;
 /// Laptop matching to determine capabilities
 pub mod laptops;
 
+pub mod systemd;
+
 /// Fetch all supported functions for the laptop
 pub mod ctrl_supported;
 
-mod error;
+pub mod error;
+
+use std::future::Future;
 
 use crate::error::RogError;
-use config::Config;
+use async_trait::async_trait;
-use zbus::ObjectServer;
+use log::{debug, warn};
+use logind_zbus::manager::ManagerProxy;
+use zbus::{export::futures_util::StreamExt, zvariant::ObjectPath, Connection, SignalContext};
 
-pub static VERSION: &str = env!("CARGO_PKG_VERSION");
+/// 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>(SignalContext, 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 CtrlRogBios {
+///     task_watch_item!(panel_od platform);
+///     task_watch_item!(gpu_mux_mode platform);
+/// }
+/// ```
+#[macro_export]
+macro_rules! task_watch_item {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalContext<'static>,
+        ) -> Result<(), RogError> {
+            use zbus::export::futures_util::StreamExt;
 
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(mut watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                let value = ctrl.$name();
+                                concat_idents::concat_idents!(notif_fn = notify_, $name {
+                                    Self::notif_fn(&signal_ctxt, value).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");
+
+#[async_trait]
 pub trait Reloadable {
-    fn reload(&mut self) -> Result<(), RogError>;
+    async fn reload(&mut self) -> Result<(), RogError>;
 }
 
-pub trait ZbusAdd {
+#[async_trait]
-    fn add_to_server(self, server: &mut ObjectServer);
+pub trait ZbusRun {
+    async fn add_to_server(self, server: &mut Connection);
+
+    async fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) {
+        server
+            .object_server()
+            .at(&ObjectPath::from_str_unchecked(path), iface)
+            .await
+            .map_err(|err| {
+                warn!("{}: add_to_server {}", path, err);
+                err
+            })
+            .ok();
+    }
 }
 
+/// Set up a task to run on the async executor
+#[async_trait]
 pub trait CtrlTask {
-    fn do_task(&mut self) -> Result<(), RogError>;
+    fn zbus_path() -> &'static str;
-}
 
-pub trait CtrlTaskComplex {
+    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
-    type A;
+        SignalContext::new(connection, Self::zbus_path())
+    }
 
-    fn do_task(&mut self, config: &mut Config, event: Self::A);
+    /// Implement to set up various tasks that may be required, using the `Executor`.
+    /// No blocking loops are allowed, or they must be run on a separate thread.
+    async fn create_tasks(&self, signal: SignalContext<'static>) -> Result<(), RogError>;
+
+    // /// 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.
+    async fn create_sys_event_tasks<
+        Fut1,
+        Fut2,
+        Fut3,
+        Fut4,
+        F1: Send + 'static,
+        F2: Send + 'static,
+        F3: Send + 'static,
+        F4: Send + 'static,
+    >(
+        &self,
+        mut on_sleep: F1,
+        mut on_wake: F2,
+        mut on_shutdown: F3,
+        mut on_boot: F4,
+    ) where
+        F1: FnMut() -> Fut1,
+        F2: FnMut() -> Fut2,
+        F3: FnMut() -> Fut3,
+        F4: FnMut() -> Fut4,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
+        let connection = Connection::system()
+            .await
+            .expect("Controller could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("Controller could not create ManagerProxy");
+
+        tokio::spawn(async move {
+            if let Ok(mut notif) = manager.receive_prepare_for_sleep().await {
+                while let Some(event) = notif.next().await {
+                    if let Ok(args) = event.args() {
+                        if args.start {
+                            debug!("Doing on_sleep()");
+                            on_sleep().await;
+                        } else if !args.start() {
+                            debug!("Doing on_wake()");
+                            on_wake().await;
+                        }
+                    }
+                }
+            }
+        });
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("Controller could not create ManagerProxy");
+
+        tokio::spawn(async move {
+            if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await {
+                while let Some(event) = notif.next().await {
+                    if let Ok(args) = event.args() {
+                        if args.start {
+                            debug!("Doing on_shutdown()");
+                            on_shutdown().await;
+                        } else if !args.start() {
+                            debug!("Doing on_boot()");
+                            on_boot().await;
+                        }
+                    }
+                }
+            }
+        });
+    }
 }
 
 pub trait GetSupported {

daemon/src/systemd.rs

@@ -0,0 +1,111 @@
+use std::process::Command;
+
+use crate::error::RogError;
+
+/// An action for `systemctl`
+#[derive(Debug, Copy, Clone)]
+pub enum SystemdUnitAction {
+    Stop,
+    Start,
+    Restart,
+}
+
+impl From<SystemdUnitAction> for &str {
+    fn from(s: SystemdUnitAction) -> Self {
+        match s {
+            SystemdUnitAction::Stop => "stop",
+            SystemdUnitAction::Start => "start",
+            SystemdUnitAction::Restart => "restart",
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum SystemdUnitState {
+    Active,
+    Inactive,
+    Masked,
+    Disabled,
+    Enabled,
+}
+
+impl From<SystemdUnitState> for &str {
+    fn from(s: SystemdUnitState) -> Self {
+        match s {
+            SystemdUnitState::Active => "active",
+            SystemdUnitState::Inactive => "inactive",
+            SystemdUnitState::Masked => "masked",
+            SystemdUnitState::Disabled => "disabled",
+            SystemdUnitState::Enabled => "enabled",
+        }
+    }
+}
+
+/// Change the state of a systemd unit. Blocks while running command.
+pub fn do_systemd_unit_action(action: SystemdUnitAction, unit: &str) -> Result<(), RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg(<&str>::from(action));
+    cmd.arg(unit);
+
+    let status = cmd
+        .status()
+        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+    if !status.success() {
+        let msg = format!("systemctl {action:?} {unit} failed: {status:?}",);
+        return Err(RogError::SystemdUnitAction(msg));
+    }
+    Ok(())
+}
+
+/// Get systemd unit state. Blocks while command is run.
+pub fn is_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<bool, RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-active");
+    cmd.arg(unit);
+
+    let output = cmd
+        .output()
+        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+    if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+/// Get systemd unit state. Blocks while command is run.
+pub fn is_systemd_unit_enabled(state: SystemdUnitState, unit: &str) -> Result<bool, RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-enabled");
+    cmd.arg(unit);
+
+    let output = cmd
+        .output()
+        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+    if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+/// Wait for a systemd unit to change to `state`. Checks state every 250ms for 3 seconds. Blocks while running wait.
+pub fn wait_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<(), RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-active");
+    cmd.arg(unit);
+
+    let mut count = 0;
+
+    while count <= (4 * 3) {
+        // 3 seconds max
+        let output = cmd
+            .output()
+            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+        if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
+            return Ok(());
+        }
+        // fine to block here, nobody doing shit now
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        count += 1;
+    }
+    Err(RogError::SystemdUnitWaitTimeout(<&str>::from(state).into()))
+}

data/90-asusd-nvidia-pm.rules

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

data/90-nvidia-screen-G05.conf

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

data/_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,12 +0,0 @@
-[Unit]
-Description=ASUS Notebook Control
-After=basic.target syslog.target
-
-[Service]
-ExecStart=/usr/bin/asusd
-Restart=on-failure
-Type=dbus
-BusName=org.asuslinux.Daemon
-
-[Install]
-WantedBy=multi-user.target

data/asusd-ledmodes.toml

@@ -1,90 +1,204 @@
+[[led_data]]
+prod_family = "ASUS TUF Gaming F15"
+board_names = ["FX506HC"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "TUF"
+board_names = ["FA507"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "TUF Gaming"
+board_names = ["FX505D"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ASUS TUF Gaming A15"
+board_names = ["FA506I"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false
+
 [[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
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "Zephyrus M"
-board_names = ["GU502GV"]
+board_names = ["GU502G"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
-per_key = true
-
-[[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
+multizone = []
 per_key = false
 
 [[led_data]]
-prod_family = "Zephyrus"
+prod_family = "ROG Zephyrus M15"
-board_names = ["GM501GM", "GX531"]
+board_names = ["GU502L"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = []
+per_key = true
+
+[[led_data]]
+prod_family = "ROG Zephyrus M16"
+board_names = ["GU603Z", "GU603H"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Zephyrus S17"
+board_names = ["GX703H"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = []
+per_key = false
+
+
+[[led_data]]
+prod_family = "Zephyrus"
+board_names = ["GM501G", "GX531"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["G531GW", "G733QS", "G733QR"]
+board_names = ["G531GW", "G533QR", "G533QS", "G733Q", "G513QR", "G713QR", "G513QM", "G713IC", "G713RS"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["GX531", "G512LV", "G712LV", "G712LW"]
+board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512", "G713RM", "G713RW"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
 board_names = ["G512LI", "G712LI", "G531GD"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = false
+multizone = []
 per_key = false
 
+[[led_data]]
+prod_family = "ROG Strix"
+board_names = ["G513IM"]
+standard = ["Flash", "Static", "Breathe", "Strobe", "Rainbow"]
+multizone = []
+per_key = true
+
 [[led_data]]
 prod_family = "Strix"
 board_names = ["G731GV", "G731GW", "G531GV"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
+per_key = false
+
+[[led_data]]
+prod_family = "Strix"
+board_names = ["GL504G"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
 per_key = false
 
 [[led_data]]
 prod_family = "Strix"
 board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = false
+multizone = []
 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
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = true
 
 [[led_data]]
 prod_family = "ROG"
 board_names = ["GL553VE"]
 standard = ["Static", "Breathe", "Strobe"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus G14"
 board_names = ["GA401Q"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
-per_key = false
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Zephyrus G14"
+board_names = ["GA402R"]
+standard = ["Static", "Breathe", "Pulse", "Rainbow"]
+multizone = []
+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 = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Zephyrus G15"
+board_names = ["GA503Q", "GA503R"]
+standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
+multizone = []
+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 = []
+per_key = true
+
+[[led_data]]
+prod_family = "ROG Zephyrus Duo 15 SE"
+board_names = ["GX551Q"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = []
+per_key = true
+
+[[led_data]]
+prod_family = "ROG Flow X13"
+board_names = ["GV301Q"]
+standard = ["Static", "Breathe", "Pulse"]
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Strix"
+board_names = ["G513IC", "G513RC", "G513RM"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Flow X16"
+board_names = ["GV601R"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false

data/asusd.rules

@@ -1,2 +1,20 @@
-ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
+#ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
-ACTION=="add|remove", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", RUN+="systemctl restart asusd.service"
+#ACTION=="add|remove", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", RUN+="systemctl restart asusd.service"
+
+ENV{DMI_VENDOR}="$attr{[dmi/id]sys_vendor}"
+ENV{DMI_VENDOR}!="ASUSTeK COMPUTER INC.", GOTO="asusd_end"
+
+ENV{DMI_FAMILY}="$attr{[dmi/id]product_family}"
+ENV{DMI_FAMILY}=="*TUF*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*ROG*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Zephyrus*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Strix*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Vivo*ook*", GOTO="asusd_start"
+# No match so
+GOTO="asusd_end"
+
+LABEL="asusd_start"
+ACTION=="add|change", DRIVER=="asus-nb-wmi", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
+ACTION=="add|remove", DRIVER=="asus-nb-wmi", TAG+="systemd", RUN+="systemctl restart asusd.service"
+
+LABEL="asusd_end"

data/asusd.service

@@ -2,12 +2,17 @@
 Description=ASUS Notebook Control
 StartLimitInterval=200
 StartLimitBurst=2
-Before=display-manager.service
+Before=multi-user.target
 
 [Service]
+Environment=IS_SERVICE=1
+Environment=RUST_LOG="info"
+ExecStartPre=/bin/sleep 2
 ExecStart=/usr/bin/asusd
 Restart=on-failure
 Restart=always
 RestartSec=1
 Type=dbus
-BusName=org.asuslinux.Daemon
+BusName=org.asuslinux.Daemon
+SELinuxContext=system_u:system_r:unconfined_t:s0
+#SELinuxContext=system_u:object_r:modules_object_t:s0

data/completions/asusctl.fish

@@ -1,77 +0,0 @@
-# Author: AlenPaulVarghese <alenpaul2001@gmail.com>
-
-set -l progname asusctl
-
-set -l noopt "not __fish_contains_opt -s -s h -s v -s s -s k -s f -s c help version show-supported kbd-bright fan-mode chg-limit; and not __fish_seen_subcommand_from led-mode profile graphics;"
-
-
-set -l gmod_options '__fish_contains_opt -s m mode;'
-set -l fan_options '__fish_contains_opt -s f fan-mode;'
-set -l led_options '__fish_seen_subcommand_from led-mode;'
-set -l profile_options '__fish_seen_subcommand_from profile;'
-set -l keyboard_options '__fish_contains_opt -s k kbd-bright;'
-set -l graphics_options '__fish_seen_subcommand_from graphics;'
-
-set -l fan_modes 'silent normal boost'
-set -l brightness_modes 'off low med high'
-set -l led_modes 'static breathe strobe rainbow comet'
-set -l graphics_modes 'nvidia hybird compute integrated'
-
-
-complete -c $progname -e
-complete -c $progname -f
-
-# asusctl completion
-complete -c $progname -s h -f -l help -n "$noopt" -d "print help message"
-complete -c $progname -s v -f -l version -n "$noopt" -d "show program version number"
-complete -c $progname -s s -f -l show-supported -n "$noopt" -d "show supported functions of this laptop"
-complete -c $progname -s k -f -l kbd-bright -n "$noopt" -d "set led brightness"
-complete -c $progname -s f -f -l fan-mode -n "$noopt" -d "set fan mode independent of profile"
-complete -c $progname -s c -f -l chg-limit -n "$noopt" -d "set charge limit <20-100>"
-complete -c $progname -f -a "led-mode" -n "$noopt" -d "Set the keyboard lighting from built-in modes"
-complete -c $progname -f -a "profile" -n "$noopt" -d "Create and configure profiles"
-complete -c $progname -f -a "graphics" -n "$noopt" -d "Set the graphics mode"
-
-# brightness completion
-complete -c $progname -n "$keyboard_options" -d "available brightness modes" -a "$brightness_modes"
-
-# fan completion
-complete -c $progname -n "$fan_options" -d "available fan modes" -a $fan_modes
-
-# graphics completion
-set -l gopt 'not __fish_contains_opt -s h -s g -s m -s p help mode get pow;'
-
-complete -c $progname -n "$graphics_options and $gopt" -a "-h" -d "print help message"
-complete -c $progname -n "$graphics_options and $gopt" -a "-g" -d "Get the current mode"
-
-complete -c $progname -s h -f -l help -n "$graphics_options and $gopt" -d "print help message"
-complete -c $progname -s m -f -l mode -n "$graphics_options and $gopt" -d "Set graphics mode: <nvidia, hybrid, compute, integrated>"
-complete -c $progname -s g -f -l get -n "$graphics_options and $gopt" -d "Get the current mode"
-complete -c $progname -s p -f -l pow -n "$graphics_options and $gopt" -d "Get the current power status"
-
-complete -c $progname -n "$graphics_options and $gmod_options" -d "available graphics modes" -a "$graphics_modes"
-
-# led-mode completion
-complete -c $progname -n "$led_options" -a "-h" -d "print help message"
-complete -c $progname -n "$led_options" -a "-n" -d "switch to next aura mode"
-
-complete -c $progname -s h -f -l help -n "$led_options" -d "print help message"
-complete -c $progname -s n -f -l next-mode -n "$led_options" -d "switch to nex aura mode"
-complete -c $progname -s p -f -l prev-mode -n "$led_options" -d "switch to previous aura mode"
-complete -c $progname -n "$led_options" -d "available led modes" -a "$led_modes"
-
-# profile completion
-set -l popt 'not __fish_contains_opt -s h -s n -s c -s t -s m -s M -s f help next create turbo min-percentage max-percentage fan-preset;'
-
-complete -c $progname -n "$profile_options and $popt" -a "-h" -d "print help message"
-complete -c $progname -n "$profile_options and $popt" -a "-n" -d "toggle to next profile in list"
-
-complete -c $progname -s h -f -l help -n "$profile_options and $popt" -d "print help message"
-complete -c $progname -s n -f -l next -n "$profile_options and $popt" -d "toggle to next profile in list"
-complete -c $progname -s c -f -l create -n "$profile_options and $popt" -d "create the profile if it doesn't exist"
-complete -c $progname -s t -f -l turbo -n "$profile_options and $popt" -d "enable or disable cpu turbo"
-complete -c $progname -s m -f -l min-percentage -n "$profile_options and $popt" -d "set min cpu scaling (intel)"
-complete -c $progname -s M -f -l max-percentage -n "$profile_options and $popt" -d "set max cpu scaling (intel)"
-complete -c $progname -s f -f -l fan-preset -n "$profile_options and $popt" -d "<silent, normal, boost>"
-complete -c $progname -n "$profile_option and __fish_contains_opt fan-preset" -d "available fan modes" -a $fan_modes
-

data/icons/scalable/gpu-compute.svg

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

data/icons/scalable/gpu-hybrid.svg

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

data/icons/scalable/gpu-integrated.svg

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

data/icons/scalable/gpu-nvidia.svg

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

data/icons/scalable/gpu-vfio.svg

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

data/icons/scalable/notification-reboot.svg

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

data/user-example.json

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

deny.toml

@@ -0,0 +1,69 @@
+# https://embarkstudios.github.io/cargo-deny/
+
+targets = [
+    { triple = "aarch64-apple-darwin" },
+    { triple = "aarch64-linux-android" },
+    { triple = "wasm32-unknown-unknown" },
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-linux-musl" },
+]
+
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+ignore = [
+    "RUSTSEC-2020-0071", # https://rustsec.org/advisories/RUSTSEC-2020-0071 - chrono/time: Potential segfault in the time crate
+    "RUSTSEC-2020-0159", # https://rustsec.org/advisories/RUSTSEC-2020-0159 - chrono/time: Potential segfault in localtime_r invocations
+    "RUSTSEC-2021-0127", # https://rustsec.org/advisories/RUSTSEC-2021-0127 - https://github.com/bheisler/criterion.rs/issues/534
+]
+
+[bans]
+multiple-versions = "deny"
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+deny = [
+    { name = "openssl" },     # prefer rustls
+    { name = "openssl-sys" }, # prefer rustls
+]
+
+skip-tree = [
+    { name = "criterion" }, # dev-dependency
+    { name = "glium" },     # legacy crate, lots of old dependencies
+    { name = "rfd" },       # example dependency
+    { name = "three-d" },   # example dependency
+]
+
+
+[licenses]
+unlicensed = "deny"
+allow-osi-fsf-free = "neither"
+confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
+copyleft = "deny"
+allow = [
+    "Apache-2.0",         # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause",       # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause",       # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "BSL-1.0",            # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "CC0-1.0",            # https://creativecommons.org/publicdomain/zero/1.0/
+    "ISC",                # https://tldrlegal.com/license/-isc-license
+    "LicenseRef-UFL-1.0", # https://tldrlegal.com/license/ubuntu-font-license,-1.0 - no official SPDX, see https://github.com/emilk/egui/issues/2321
+    "MIT",                # https://tldrlegal.com/license/mit-license
+    "MPL-2.0",            # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11
+    "OFL-1.1",            # https://spdx.org/licenses/OFL-1.1.html
+    "OpenSSL",            # https://www.openssl.org/source/license.html
+    "Unicode-DFS-2016",   # https://spdx.org/licenses/Unicode-DFS-2016.html
+    "Zlib",               # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+]
+
+[[licenses.clarify]]
+name = "webpki"
+expression = "ISC"
+license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
+
+[[licenses.clarify]]
+name = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
+

design-patterns.md

@@ -0,0 +1,147 @@
+# Daemon
+
+## Controller pattern
+
+There are a series of traits in the daemon for use with controller objects. Not all traits are required:
+
+- `Reloadable`, for controllers that need the ability to reload (typically on start)
+- `ZbusAdd`, for controllers that have zbus derive. These need to run on the zbus server.
+- `CtrlTask`, for controllers that need to run tasks every loop.
+- `GetSupported`, see if the hardware/functions this controller requires are supported.
+
+The first 3 trait objects get owned by the daemon methods that required them, which is why an `Arc<Mutex<T>>` is required.
+
+Generally the actual controller object will need to live in its own world as its own struct.
+Then for each trait that is required a new struct is required that can have the trait implemented, and that struct would have a reference to the main controller via `Arc<Mutex<T>>`.
+
+### Example
+
+Main controller:
+
+For a very simple controller that doesn't need exclusive access you can clone across threads
+
+```rust
+#[derive(Clone)]
+pub struct CtrlAnime {
+    <things the controller requires>
+    config: Arc<Mutex<Config>>,
+}
+
+// This is the task trait used for such things as file watches, or logind
+// notifications (boot/suspend/shutdown etc)
+impl crate::CtrlTask for CtrlAnime {}
+
+// The trait to easily add the controller to Zbus to enable the zbus derived functions
+// to be polled, run, react etc.
+impl crate::ZbusAdd for CtrlAnime {}
+
+impl CtrlAnime {}
+```
+
+ Otherwise, you will need to share the controller via mutex
+
+```rust
+pub struct CtrlAnime {
+    <things the controller requires>
+}
+// Like this
+#[derive(Clone)]
+pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
+
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
+
+impl CtrlAnime {}
+```
+
+The task trait:
+
+```rust
+// Mutex should always be async mutex
+pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
+
+impl crate::CtrlTask for CtrlAnimeTask {
+    // This will run once only
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+       let lock self.inner.lock().await;
+        <some action>
+        Ok(())
+    }
+
+    // This will run until the notification stream closes (which in most cases will be never)
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let inner1 = self.inner.clone();
+        let inner2 = self.inner.clone();
+        let inner3 = self.inner.clone();
+        let inner4 = self.inner.clone();
+        // This is a free method on CtrlTask trait
+        self.create_sys_event_tasks(
+            // Loop is required to try an attempt to get the mutex *without* blocking
+            // other threads - it is possible to end up with deadlocks otherwise.
+            move || loop {
+                if let Some(lock) = inner1.try_lock() {
+                    run_action(true, lock, inner1.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner2.try_lock() {
+                    run_action(false, lock, inner2.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner3.try_lock() {
+                    run_action(true, lock, inner3.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner4.try_lock() {
+                    run_action(false, lock, inner4.clone());
+                    break;
+                }
+            },
+        )
+        .await;
+    }
+}
+```
+
+The reloader trait
+
+```rust
+pub struct CtrlAnimeReloader(Arc<Mutex<CtrlAnime>>);
+
+impl crate::Reloadable for CtrlAnimeReloader {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let lock = self.inner.lock().await;
+        <some action>
+        Ok(())
+    }
+}
+```
+
+The Zbus requirements:
+
+```rust
+pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
+
+#[async_trait]
+impl crate::ZbusAdd for CtrlAnimeZbus {
+    fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        // This is a provided free helper trait with pre-set body. It will move self in-to.
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    async fn <zbus method>() {
+       let lock = self.inner.lock().await;
+        <some action>
+    }
+}
+```
+
+The controller can then be added to the daemon parts as required.

rog-anime/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rog_anime"
-version = "1.0.2"
 license = "MPL-2.0"
+version.workspace = true
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
@@ -9,23 +9,25 @@ homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 documentation = "https://docs.rs/rog-anime"
 description = "Types useful for translating images and other data for display on the ASUS AniMe Matrix display"
 keywords = ["ROG", "ASUS", "AniMe"]
-edition = "2018"
+edition = "2021"
 exclude = ["data"]
 
 [features]
-default = ["dbus"]
+default = ["dbus", "detect"]
-dbus = ["zbus", "zvariant", "zvariant_derive"]
+dbus = ["zbus"]
+detect = ["sysfs-class"]
 
 [dependencies]
-png_pong = "^0.8.0"
+png_pong.workspace = true
-pix = "0.13"
+pix.workspace = true
-gif = "^0.11.2"
+gif.workspace = true
+log.workspace = true
 
-serde = "^1.0"
+serde.workspace = true
-serde_derive = "^1.0"
+serde_derive.workspace = true
 
-glam = { version = "0.14.0", features = ["serde"] }
+glam.workspace = true
 
-zbus = { version = "^1.9.1", optional = true }
+zbus = { workspace = true, optional = true }
-zvariant = { version = "^2.6", optional = true }
+
-zvariant_derive = { version = "^2.6", optional = true }
+sysfs-class = { workspace = true, optional = true }