4.5.1-RC1

Add led_data for 2022 ASUS TUF Gaming A15 FA506IE

See merge request asus-linux/asusctl!137

.gitignore

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

.gitlab-ci.yml

@@ -1,7 +1,7 @@
-image: rustdocker/rust:stable
+image: rust:latest
 
 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 libdbus-1-dev libclang-dev libudev-dev libfontconfig1-dev
 
 stages:
     - test
@@ -9,7 +9,10 @@ stages:
 
 test:
   script:
-    - cargo check #+nightly check --features "clippy"
+    - rustup component add clippy
+    - cargo check
+    - cargo clippy
+    - cargo test
 
 build:
   only:

CHANGELOG.md

@@ -5,6 +5,159 @@ 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.1- RC1]
+### 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
+
+## [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

Cargo.toml

@@ -1,14 +1,54 @@
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
+members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+
+[workspace.package]
+version = "4.5.1-RC1"
+
+[workspace.dependencies]
+async-trait = "^0.1"
+tokio = { version = "^1.21.2", features = ["macros", "rt-multi-thread", "time", "sync"]}
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^1.2"
+
+zbus = "^3.4"
+zbus_macros = "^3.4"
+zvariant = "^3.7"
+zvariant_derive = "^3.7"
+logind-zbus = { version = "^3.0" } #, 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.9.3"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = "^0.6"
+rusb = "^0.9"
+sysfs-class = "^0.1.2"
+inotify = "^0.10.0"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.3"
+gif = "^0.11"
+
+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]

MANUAL.md

@@ -60,17 +60,17 @@ The defaults are located at `/etc/asusd/asusd-ledmodes.toml`, and on `asusd` sta
 Example:
 ```toml
 [[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = false
+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 keyboards have 4 zones of LED control, this enables setting a colour in each zone. The keyboard must support this or it has no effect.
+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
@@ -90,14 +90,14 @@ where the number is a percentage.
 
 Some options that you find in Armory Crate are available under this controller, so far there is:
 
-- POST sound: this is the sound you here on bios boot post
-- G-Sync: this controls if the dGPU (Nvidia) is the *only* GPU, making it the main GPU and disabling the iGPU
+- POST sound: this is the sound you hear on bios boot post
+- GPU MUX: this controls if the dGPU is the *only* GPU, making it the main GPU and disabling the iGPU
 
 These options are not written to the config file as they are stored in efivars. The only way to change these is to use the exposed safe dbus methods, or use the `asusctl` CLI tool.
 
 ### Profiles
 
-asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.9.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is included in the "rog" kernels we build for fedora and arch, and will hit kernel 5.15 upstream.
+asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.10.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is merged to 5.15 kernel upstream.
 
 A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n` to cycle through the 3 profiles:
 1. Balanced
@@ -106,7 +106,7 @@ A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n`
 
 #### Fan curves
 
-Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/8/29/50) which is still in review as of 29/09/21. As with Profiles, this is included in the kernels we build, and will hit 5.15 kernel upstream.
+Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/10/23/250) which is accepted for the 5.17 kernel release .
 
 The fan curve format can be of varying formats:
 
@@ -131,6 +131,101 @@ As of now only AniMe is active in this with configuration in `~/.config/rog/`. O
 
 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"`
@@ -293,7 +388,7 @@ A plain non-float integer.
 
 ## asusctl
 
-`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. I can be used in any place a terminal app can be used.
+`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. It can be used in any place a terminal app can be used.
 
 This program will query `asusd` for the `Support` level of the laptop and show or hide options according to this support level.
 
@@ -356,4 +451,4 @@ Reference to any ASUS products, services, processes, or other information and/or
 
 The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
 
----
+---

Makefile

@@ -11,10 +11,10 @@ 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
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
@@ -39,22 +39,28 @@ 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/$(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/$(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/icons/asus_notif_orange.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_orange.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_white.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_white.png"
 
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-compute.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-hybrid.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
@@ -63,19 +69,19 @@ install:
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
 	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
 
-	$(INSTALL_DATA) "./data/_asusctl" "$(DESTDIR)$(zshcpl)/_asusctl"
-	$(INSTALL_DATA) "./data/completions/asusctl.fish" "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
-	cd rog-anime/data && find "./anime" -type f -exec install -Dm 755 "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+	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/99-$(BIN_D).rules"
 	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 	rm -f "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	rm -r "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
@@ -85,9 +91,8 @@ uninstall:
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
-	rm -f "$(DESTDIR)$(zshcpl)/_asusctl"
-	rm -f "$(DESTDIR)$(datarootdir)/fish/vendor_completions.d/asusctl.fish"
 	rm -rf "$(DESTDIR)$(datarootdir)/asusd"
+	rm -rf "$(DESTDIR)$(datarootdir)/rog-gui"
 
 update:
 	cargo update
@@ -107,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

@@ -2,13 +2,16 @@
 
 [![](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:** Do not run the main branch of this repo unless you have all the asus-wmi kernel patches. You should use stable kernels + tagged releases.
+
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
 
-## Kernel patches required
+Now includes a GUI, `rog-control-center`.
 
-1. https://lkml.org/lkml/2021/8/20/232
-2. https://lkml.org/lkml/2021/8/18/1022
+## Kernel support
+
+**The minimum supported kernel version is 5.17**
 
 ## Goals
 
@@ -18,16 +21,12 @@ but can also be used with non-asus laptops with reduced features.
 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 (while asusd might still run fine on them). For best support use fedora 32+ Workstation.
+supported. All other distros are *not* supported (while asusd might still run fine on them).
+For best support use fedora 36+ Workstation.
 
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
 a system-level daemon should.
 
-**NOTICE:**
-
-Various patches are required for keyboard support. See [this post](https://asus-linux.org/blog/updates-2021-05-06/) for details on status and which kernels will have which patches.
-
 ## Discord
 
 [Discord server link](https://discord.gg/4ZKGd7Un5t)
@@ -42,12 +41,14 @@ 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
-will probably suffer another rename once it becomes generic enough to do so.
+and AniMe parts should work regardless of your latop make.
+
+**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
@@ -55,33 +56,50 @@ will probably suffer another rename once it becomes generic enough to do so.
 - [X] Saving settings for reload
 - [X] AniMatrix display on G14 models that include it
 - [X] Set battery charge limit (with kernel supporting this)
-- [X] Fan curve control on G14 + G15. Requires kernel patch (should reach 5.15 kernel)
+- [X] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
 - [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)
+
+# GUI
+
+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.
+
+![](/extra/system.png)
+![](/extra/fan-curves.png)
+![](/extra/keyboard.png)
 
 # BUILDING
 
-Requirements are rust >= 1.47 installed from rustup.io if the distro provided version is too old, and `make`.
+Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
 
-**Ubuntu:** `apt install libclang-dev libudev-dev`
+**Ubuntu (unsuported):**
 
-**fedora:** `dnf install clang-devel systemd-devel`
+    apt install libclang-dev libudev-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    make
+    sudo make install
+
+**fedora:**
+
+    dnf install cmake clang-devel systemd-devel gtk3-devel
+    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.
 
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/) for the latest versions of Fedora, Ubuntu, and openSUSE.
-
-### Ubuntu
-
-    sudo su -c "echo 'deb https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/ /' > /etc/apt/sources.list.d/luke_nukem.list"
-    curl -fsSL https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/Release.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/home_luke_nukem.gpg > /dev/null
-    sudo apt-get update
-    sudo apt-get install asusctl dkms-hid-asus-rog
-
-
----
-
-Run `make` then `sudo make install` then reboot.
+=======
 
 The default init method is to use the udev rule, this ensures that the service is
 started when the device is initialised and ready.

asus-notify/Cargo.toml

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

asus-notify/src/main.rs

@@ -1,103 +0,0 @@
-use notify_rust::{Hint, Notification, NotificationHandle};
-use rog_aura::AuraEffect;
-use rog_dbus::{DbusProxies, Signals};
-use rog_profiles::Profile;
-use std::error::Error;
-use std::thread::sleep;
-use std::time::Duration;
-
-const NOTIF_HEADER: &str = "ROG Control";
-
-macro_rules! notify {
-    ($notifier:ident, $last_notif:ident, $data:expr) => {
-        if let Some(notif) = $last_notif.take() {
-            notif.close();
-        }
-        if let Ok(x) = $notifier($data) {
-            $last_notif = Some(x);
-        }
-    };
-}
-
-macro_rules! base_notification {
-    ($body:expr) => {
-        Notification::new()
-            .summary(NOTIF_HEADER)
-            .body($body)
-            .timeout(2000)
-            .show()
-    };
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
-
-    let (proxies, conn) = DbusProxies::new()?;
-    let signals = Signals::new(&proxies)?;
-
-    let mut last_notification: Option<NotificationHandle> = None;
-
-    let recv = proxies.setup_recv(conn);
-    let mut err_count = 0;
-
-    loop {
-        sleep(Duration::from_millis(100));
-        if let Err(err) = recv.next_signal() {
-            if err_count < 3 {
-                err_count += 1;
-                println!("{}", err);
-            }
-            if err_count == 3 {
-                err_count += 1;
-                println!("Max error count reached. Spooling silently.");
-            }
-            sleep(Duration::from_millis(2000));
-            continue;
-        }
-        err_count = 0;
-
-        if let Ok(data) = signals.led_mode.try_recv() {
-            notify!(do_led_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.profile.try_recv() {
-            notify!(do_thermal_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.charge.try_recv() {
-            notify!(do_charge_notif, last_notification, &data);
-        }
-    }
-}
-
-fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
-    let icon = match profile {
-        Profile::Balanced => "asus_notif_yellow",
-        Profile::Performance => "asus_notif_red",
-        Profile::Quiet => "asus_notif_green",
-    };
-    let profile: &str = (*profile).into();
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!(
-            "Thermal profile changed to {}",
-            profile.to_uppercase(),
-        ))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
-}
-
-fn do_led_notif(ledmode: &AuraEffect) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!(
-        "Keyboard LED mode changed to {}",
-        ledmode.mode_name()
-    ))
-}
-
-fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("Battery charge limit changed to {}", limit))
-}

asusctl/Cargo.toml

@@ -1,26 +1,23 @@
 [package]
 name = "asusctl"
-version = "4.0.6"
 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
+edition = "2021"
+version.workspace = true
 
 [dependencies]
-zbus = "^1.9.1"
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
-rog_supported = { path = "../rog-supported" }
+rog_platform = { path = "../rog-platform" }
 daemon = { path = "../daemon" }
-gumdrop = "^0.8"
-toml = "^0.5.8"
 
-sysfs-class = "^0.1.2"
+gumdrop.workspace = true
+toml.workspace = true
+sysfs-class.workspace = true
 
 [dev-dependencies]
-tinybmp = "^0.2.3"
-glam = "0.14.0"
+gif.workspace = true
+tinybmp.workspace = true
+glam.workspace = true
 rog_dbus = { path = "../rog-dbus" }
-gif = "^0.11.2"

asusctl/examples/anime-diag-png.rs

@@ -1,10 +1,10 @@
 use std::{env, error::Error, path::Path, process::exit};
 
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {
@@ -13,13 +13,19 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
-    let matrix =
-        AnimeDiagonal::from_png(Path::new(&args[1]), None, args[2].parse::<f32>().unwrap())?;
+    let matrix = AnimeDiagonal::from_png(
+        Path::new(&args[1]),
+        None,
+        args[2].parse::<f32>().unwrap(),
+        AnimeType::GA401,
+    )?;
+
+    let anime_type = get_anime_type()?;
 
     client
         .proxies()
         .anime()
-        .write(<AnimeDataBuffer>::from(&matrix))
+        .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_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -9,10 +9,10 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     for step in (2..50).rev() {
-        let mut matrix = AnimeDiagonal::new(None);
+        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;
@@ -25,8 +25,12 @@ fn main() {
             }
         }
 
-        let m = <AnimeDataBuffer>::from(&matrix);
-        client.proxies().anime().write(m).unwrap();
+        let anime_type = get_anime_type().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, ActionLoader, Sequences};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, ActionData, ActionLoader, Sequences};
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {
@@ -14,7 +14,8 @@ fn main() {
 
     let path = Path::new(&args[1]);
     let brightness = args[2].parse::<f32>().unwrap();
-    let mut seq = Sequences::new();
+    let anime_type = get_anime_type().unwrap();
+    let mut seq = Sequences::new(anime_type);
     seq.insert(
         0,
         &ActionLoader::AsusAnimation {

asusctl/examples/anime-grid.rs

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

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

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::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -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::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -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,6 +29,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             args[5].parse::<f32>().unwrap(),
         ),
         args[6].parse::<f32>().unwrap(),
+        anime_type,
     )?;
 
     loop {
@@ -38,7 +42,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         client
             .proxies()
             .anime()
-            .write(<AnimeDataBuffer>::from(&matrix))
+            .write(<AnimeDataBuffer>::try_from(&matrix)?)
             .unwrap();
         sleep(Duration::from_micros(500));
     }

asusctl/examples/aura-rgb-ball.rs

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

@@ -1,52 +1,32 @@
-use rog_aura::{GX502Layout, Key, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
+//! 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 (dbus, _) = RogDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-    let layout = GX502Layout::default();
-
-    dbus.proxies().led().init_effect()?;
-    let rows = layout.get_rows();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let layout = KeyLayout::gx502_layout();
     loop {
-        for (r, row) in rows.iter().enumerate() {
-            for (k, key) in row.iter().enumerate() {
-                if let Some(c) = key_colours.key(*key) {
-                    *c.0 = 255;
-                };
-                // Last key of previous row
-                if k == 0 {
-                    if r == 0 {
-                        let k = &rows[rows.len() - 1][rows[rows.len() - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
-                        };
-                    } else {
-                        let k = &rows[r - 1][rows[r - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
+        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;
                         };
                     }
-                } else {
-                    let k = &rows[r][k - 1];
-                    if let Some(c) = key_colours.key(*k) {
-                        *c.0 = 0;
-                    };
                 }
-                if let Some(c) = key_colours.key(Key::Up) {
-                    *c.0 = 255;
+
+                if key.is_placeholder() {
+                    continue;
+                }
+
+                if let Some(c) = key_colours.rgb_for_key(*key) {
+                    c[0] = 255;
                 };
-                *key_colours.key(Key::Left).unwrap().0 = 255;
-                *key_colours.key(Key::Right).unwrap().0 = 255;
-                *key_colours.key(Key::Down).unwrap().0 = 255;
 
-                *key_colours.key(Key::W).unwrap().0 = 255;
-                *key_colours.key(Key::A).unwrap().0 = 255;
-                *key_colours.key(Key::S).unwrap().0 = 255;
-                *key_colours.key(Key::D).unwrap().0 = 255;
-
-                dbus.proxies().led().set_per_key(&key_colours)?;
+                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

@@ -16,6 +16,8 @@ pub struct AnimeCommand {
     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>,
 }

asusctl/src/aura_cli.rs

@@ -2,6 +2,71 @@ use gumdrop::Options;
 use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 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>,
@@ -50,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")]
@@ -59,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)]
@@ -67,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)]
@@ -77,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)]
@@ -89,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")]
@@ -152,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 {
@@ -168,6 +260,7 @@ impl From<&SingleColour> for AuraEffect {
     fn from(aura: &SingleColour) -> Self {
         Self {
             colour1: aura.colour,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -177,6 +270,7 @@ impl From<&SingleSpeed> for AuraEffect {
     fn from(aura: &SingleSpeed) -> Self {
         Self {
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -187,6 +281,7 @@ impl From<&SingleColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -197,6 +292,7 @@ impl From<&TwoColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             colour2: aura.colour2,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -207,6 +303,7 @@ impl From<&SingleSpeedDirection> for AuraEffect {
         Self {
             speed: aura.speed,
             direction: aura.direction,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -275,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

@@ -1,6 +1,6 @@
 use crate::{
     anime_cli::AnimeCommand,
-    aura_cli::{LedBrightness, SetAuraBuiltin},
+    aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin},
     profiles_cli::{FanCurveCommand, ProfileCommand},
 };
 use gumdrop::Options;
@@ -29,6 +29,10 @@ pub struct CliStart {
 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")]
@@ -49,16 +53,6 @@ pub struct LedModeCommand {
     pub next_mode: bool,
     #[options(help = "switch to previous aura mode")]
     pub prev_mode: bool,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED to enabled while the device is awake"
-    )]
-    pub awake_enable: Option<bool>,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED suspend animation to enabled while the device is suspended"
-    )]
-    pub sleep_enable: Option<bool>,
     #[options(command)]
     pub command: Option<SetAuraBuiltin>,
 }
@@ -75,18 +69,29 @@ pub struct BiosCommand {
     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, help = "read bios POST sound")]
+    #[options(no_long, short = "s", help = "read bios POST sound")]
     pub post_sound_get: bool,
     #[options(
         meta = "",
+        short = "D",
         no_long,
-        help = "activate dGPU dedicated/G-Sync: asusctl -d <true/false>, reboot required"
+        help = "Switch GPU MUX mode: 0 = Discrete, 1 = Optimus, reboot required"
     )]
-    pub dedicated_gfx_set: Option<bool>,
-    #[options(no_long, help = "get GPU mode")]
-    pub dedicated_gfx_get: bool,
+    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/main.rs

@@ -1,22 +1,24 @@
+use std::convert::TryFrom;
 use std::process::Command;
 use std::thread::sleep;
 use std::{env::args, path::Path};
 
+use aura_cli::{LedPowerCommand1, LedPowerCommand2};
 use gumdrop::{Opt, Options};
 
 use anime_cli::{AnimeActions, AnimeCommand};
 use profiles_cli::{FanCurveCommand, ProfileCommand};
+use rog_anime::usb::get_anime_type;
 use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
-use rog_aura::{self, AuraEffect};
-use rog_dbus::RogDbusClient;
-use rog_profiles::error::ProfileError;
-use rog_supported::SupportedFunctions;
-use rog_supported::{
-    AnimeSupportedFunctions, LedSupportedFunctions, PlatformProfileFunctions,
-    RogBiosSupportedFunctions,
-};
 
-use crate::aura_cli::{LedBrightness, SetAuraBuiltin};
+use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_aura::{self, AuraEffect};
+use rog_dbus::RogDbusClientBlocking;
+use rog_platform::platform::GpuMode;
+use rog_platform::supported::*;
+use rog_profiles::error::ProfileError;
+
+use crate::aura_cli::LedBrightness;
 use crate::cli_opts::*;
 
 mod anime_cli;
@@ -24,30 +26,23 @@ mod aura_cli;
 mod cli_opts;
 mod profiles_cli;
 
-const CONFIG_ADVICE: &str = "A config file need to be removed so a new one can be generated";
-
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args: Vec<String> = args().skip(1).collect();
 
-    let parsed: CliStart;
     let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
-    match CliStart::parse_args_default(&args) {
-        Ok(p) => {
-            parsed = p;
-        }
-        Err(err) if err.to_string() == missing_argument_k.to_string() => {
-            parsed = CliStart {
-                kbd_bright: Some(LedBrightness::new(None)),
-                ..Default::default()
-            };
-        }
+    let parsed = match CliStart::parse_args_default(&args) {
+        Ok(p) => p,
+        Err(err) if err.to_string() == missing_argument_k.to_string() => CliStart {
+            kbd_bright: Some(LedBrightness::new(None)),
+            ..Default::default()
+        },
         Err(err) => {
             eprintln!("source {}", err);
             std::process::exit(2);
         }
-    }
+    };
 
-    let (dbus, _) = RogDbusClient::new()
+    let (dbus, _) = RogDbusClientBlocking::new()
         .map_err(|e| {
             print_error_help(Box::new(e), None);
             std::process::exit(3);
@@ -57,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let supported = dbus
         .proxies()
         .supported()
-        .get_supported_functions()
+        .supported_functions()
         .map_err(|e| {
             print_error_help(Box::new(e), None);
             std::process::exit(4);
@@ -79,15 +74,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn print_error_help(err: Box<dyn std::error::Error>, supported: Option<&SupportedFunctions>) {
-    if do_diagnose("asusd") {
-        println!("\nError: {}\n", err);
-        print_versions();
+    check_service("asusd");
+    println!("\nError: {}\n", err);
+    print_versions();
+    println!();
+    print_laptop_info();
+    if let Some(supported) = supported {
         println!();
-        print_laptop_info();
-        if let Some(supported) = supported {
-            println!();
-            println!("Supported laptop functions:\n\n{}", supported);
-        }
+        println!("Supported laptop functions:\n\n{}", supported);
     }
 }
 
@@ -100,7 +94,7 @@ fn print_versions() {
     println!("     rog-aura v{}", rog_aura::VERSION);
     println!("     rog-dbus v{}", rog_dbus::VERSION);
     println!(" rog-profiles v{}", rog_profiles::VERSION);
-    println!("rog-supported v{}", rog_supported::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
 }
 
 fn print_laptop_info() {
@@ -112,7 +106,7 @@ fn print_laptop_info() {
     println!("Board name: {}", board_name.trim());
 }
 
-fn do_diagnose(name: &str) -> bool {
+fn check_service(name: &str) -> bool {
     if name != "asusd" && !check_systemd_unit_enabled(name) {
         println!(
             "\n\x1b[0;31m{} is not enabled, enable it with `systemctl enable {}\x1b[0m",
@@ -125,13 +119,6 @@ fn do_diagnose(name: &str) -> bool {
             name, name
         );
         return true;
-    } else {
-        println!("\nSome error happened (sorry)");
-        println!(
-            "Please use `systemctl status {}` and `journalctl -b -u {}` for more information",
-            name, name
-        );
-        println!("{}", CONFIG_ADVICE);
     }
     false
 }
@@ -139,10 +126,12 @@ fn do_diagnose(name: &str) -> bool {
 fn do_parsed(
     parsed: &CliStart,
     supported: &SupportedFunctions,
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
         Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
+        Some(CliCommand::LedPow1(pow)) => handle_led_power1(dbus, &supported.keyboard_led, pow)?,
+        Some(CliCommand::LedPow2(pow)) => handle_led_power2(dbus, &supported.keyboard_led, pow)?,
         Some(CliCommand::Profile(cmd)) => handle_profile(dbus, &supported.platform_profile, cmd)?,
         Some(CliCommand::FanCurve(cmd)) => {
             handle_fan_curve(dbus, &supported.platform_profile, cmd)?
@@ -161,8 +150,32 @@ fn do_parsed(
                 println!("{}", CliStart::usage());
                 println!();
                 if let Some(cmdlist) = CliStart::command_list() {
-                    println!("{}", cmdlist);
+                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+                    for command in commands.iter().filter(|command| {
+                        if !matches!(
+                            supported.keyboard_led.prod_id,
+                            AuraDevice::X1854
+                                | AuraDevice::X1869
+                                | AuraDevice::X1866
+                                | AuraDevice::Tuf
+                        ) && command.trim().starts_with("led-pow-1")
+                        {
+                            return false;
+                        }
+                        if supported.keyboard_led.prod_id != AuraDevice::X19B6
+                            && command.trim().starts_with("led-pow-2")
+                        {
+                            return false;
+                        }
+                        true
+                    }) {
+                        println!("{}", command);
+                    }
                 }
+
+                println!("\nExtra help can be requested on any command or subcommand:");
+                println!(" asusctl led-mode --help");
+                println!(" asusctl led-mode static --help");
             }
         }
     }
@@ -170,13 +183,13 @@ fn do_parsed(
     if let Some(brightness) = &parsed.kbd_bright {
         match brightness.level() {
             None => {
-                let level = dbus.proxies().led().get_led_brightness()?;
+                let level = dbus.proxies().led().led_brightness()?;
                 println!("Current keyboard led brightness: {}", level);
             }
             Some(level) => dbus
                 .proxies()
                 .led()
-                .set_led_brightness(<rog_aura::LedBrightness>::from(level))?,
+                .set_brightness(<rog_aura::LedBrightness>::from(level))?,
         }
     }
 
@@ -193,7 +206,9 @@ fn do_parsed(
     }
 
     if let Some(chg_limit) = parsed.chg_limit {
-        dbus.proxies().charge().write_limit(chg_limit)?;
+        dbus.proxies()
+            .charge()
+            .set_charge_control_end_threshold(chg_limit)?;
     }
 
     Ok(())
@@ -206,7 +221,7 @@ fn do_gfx() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn handle_anime(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     _supported: &AnimeSupportedFunctions,
     cmd: &AnimeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -228,9 +243,18 @@ fn handle_anime(
         dbus.proxies().anime().set_boot_on_off(anime_boot)?
     }
     if let Some(bright) = cmd.brightness {
-        dbus.proxies().anime().set_brightness(bright as f32)?
+        verify_brightness(bright);
+        dbus.proxies().anime().set_brightness(bright)?
     }
+    if cmd.clear {
+        let anime_type = get_anime_type()?;
+        let data = vec![0u8; anime_type.data_length()];
+        let tmp = AnimeDataBuffer::from_vec(anime_type, data)?;
+        dbus.proxies().anime().write(tmp)?;
+    }
+
     if let Some(action) = cmd.command.as_ref() {
+        let anime_type = get_anime_type()?;
         match action {
             AnimeActions::Image(image) => {
                 if image.help_requested() || image.path.is_empty() {
@@ -240,6 +264,7 @@ fn handle_anime(
                     }
                     std::process::exit(1);
                 }
+                verify_brightness(image.bright);
 
                 let matrix = AnimeImage::from_png(
                     Path::new(&image.path),
@@ -247,11 +272,12 @@ fn handle_anime(
                     image.angle,
                     Vec2::new(image.x_pos, image.y_pos),
                     image.bright,
+                    anime_type,
                 )?;
 
                 dbus.proxies()
                     .anime()
-                    .write(<AnimeDataBuffer>::from(&matrix))?;
+                    .write(<AnimeDataBuffer>::try_from(&matrix)?)?;
             }
             AnimeActions::PixelImage(image) => {
                 if image.help_requested() || image.path.is_empty() {
@@ -261,12 +287,18 @@ fn handle_anime(
                     }
                     std::process::exit(1);
                 }
+                verify_brightness(image.bright);
 
-                let matrix = AnimeDiagonal::from_png(Path::new(&image.path), None, image.bright)?;
+                let matrix = AnimeDiagonal::from_png(
+                    Path::new(&image.path),
+                    None,
+                    image.bright,
+                    anime_type,
+                )?;
 
                 dbus.proxies()
                     .anime()
-                    .write(<AnimeDataBuffer>::from(&matrix))?;
+                    .write(matrix.into_data_buffer(anime_type)?)?;
             }
             AnimeActions::Gif(gif) => {
                 if gif.help_requested() || gif.path.is_empty() {
@@ -276,6 +308,7 @@ fn handle_anime(
                     }
                     std::process::exit(1);
                 }
+                verify_brightness(gif.bright);
 
                 let matrix = AnimeGif::from_gif(
                     Path::new(&gif.path),
@@ -284,6 +317,7 @@ fn handle_anime(
                     Vec2::new(gif.x_pos, gif.y_pos),
                     AnimTime::Count(1),
                     gif.bright,
+                    anime_type,
                 )?;
 
                 let mut loops = gif.loops as i32;
@@ -308,11 +342,13 @@ fn handle_anime(
                     }
                     std::process::exit(1);
                 }
+                verify_brightness(gif.bright);
 
                 let matrix = AnimeGif::from_diagonal_gif(
                     Path::new(&gif.path),
                     AnimTime::Count(1),
                     gif.bright,
+                    anime_type,
                 )?;
 
                 let mut loops = gif.loops as i32;
@@ -334,17 +370,22 @@ fn handle_anime(
     Ok(())
 }
 
+fn verify_brightness(brightness: f32) {
+    if !(0.0..=1.0).contains(&brightness) {
+        println!(
+            "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
+            brightness
+        );
+        std::process::exit(1);
+    }
+}
+
 fn handle_led_mode(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &LedSupportedFunctions,
     mode: &LedModeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if mode.command.is_none()
-        && !mode.prev_mode
-        && !mode.next_mode
-        && mode.sleep_enable.is_none()
-        && mode.awake_enable.is_none()
-    {
+    if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
         if !mode.help {
             println!("Missing arg or command\n");
         }
@@ -355,11 +396,14 @@ fn handle_led_mode(
             let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
             for command in commands.iter().filter(|command| {
                 for mode in &supported.stock_led_modes {
-                    if command.contains(&<&str>::from(mode).to_lowercase()) {
+                    if command
+                        .trim()
+                        .starts_with(&<&str>::from(mode).to_lowercase())
+                    {
                         return true;
                     }
                 }
-                if supported.multizone_led_mode {
+                if !supported.multizone_led_mode.is_empty() && command.trim().starts_with("multi") {
                     return true;
                 }
                 false
@@ -385,45 +429,233 @@ fn handle_led_mode(
             println!("{}", mode.self_usage());
             return Ok(());
         }
-        match mode {
-            SetAuraBuiltin::MultiStatic(_) | SetAuraBuiltin::MultiBreathe(_) => {
-                let zones = <Vec<AuraEffect>>::from(mode);
-                for eff in zones {
-                    dbus.proxies().led().set_led_mode(&eff)?
+        dbus.proxies()
+            .led()
+            .set_led_mode(&<AuraEffect>::from(mode))?;
+    }
+
+    Ok(())
+}
+
+fn handle_led_power1(
+    dbus: &RogDbusClientBlocking,
+    supported: &LedSupportedFunctions,
+    power: &LedPowerCommand1,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if power.awake.is_none()
+        && power.sleep.is_none()
+        && power.boot.is_none()
+        && power.keyboard.is_none()
+        && power.lightbar.is_none()
+    {
+        if !power.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", power.self_usage());
+        return Ok(());
+    }
+
+    if matches!(
+        supported.prod_id,
+        AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866
+    ) {
+        handle_led_power_1_do_1866(dbus, power)?;
+        return Ok(());
+    }
+
+    if matches!(supported.prod_id, AuraDevice::Tuf) {
+        handle_led_power_1_do_tuf(dbus, power)?;
+        return Ok(());
+    }
+
+    println!("These options are for keyboards of product ID 0x1866 or TUF only");
+    Ok(())
+}
+
+fn handle_led_power_1_do_1866(
+    dbus: &RogDbusClientBlocking,
+    power: &LedPowerCommand1,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mut enabled: Vec<AuraDev1866> = Vec::new();
+    let mut disabled: Vec<AuraDev1866> = Vec::new();
+
+    let mut check = |e: Option<bool>, a: AuraDev1866| {
+        if let Some(arg) = e {
+            if arg {
+                enabled.push(a);
+            } else {
+                disabled.push(a);
+            }
+        }
+    };
+
+    check(power.awake, AuraDev1866::Awake);
+    check(power.boot, AuraDev1866::Boot);
+    check(power.sleep, AuraDev1866::Sleep);
+    check(power.keyboard, AuraDev1866::Keyboard);
+    check(power.lightbar, AuraDev1866::Lightbar);
+
+    let data = AuraPowerDev {
+        x1866: enabled,
+        x19b6: vec![],
+        tuf: vec![],
+    };
+    dbus.proxies().led().set_leds_power(data, true)?;
+
+    let data = AuraPowerDev {
+        x1866: disabled,
+        x19b6: vec![],
+        tuf: vec![],
+    };
+    dbus.proxies().led().set_leds_power(data, false)?;
+
+    Ok(())
+}
+
+fn handle_led_power_1_do_tuf(
+    dbus: &RogDbusClientBlocking,
+    power: &LedPowerCommand1,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mut enabled: Vec<AuraDevTuf> = Vec::new();
+    let mut disabled: Vec<AuraDevTuf> = Vec::new();
+
+    let mut check = |e: Option<bool>, a: AuraDevTuf| {
+        if let Some(arg) = e {
+            if arg {
+                enabled.push(a);
+            } else {
+                disabled.push(a);
+            }
+        }
+    };
+
+    check(power.awake, AuraDevTuf::Awake);
+    check(power.boot, AuraDevTuf::Boot);
+    check(power.sleep, AuraDevTuf::Sleep);
+    check(power.keyboard, AuraDevTuf::Keyboard);
+
+    let data = AuraPowerDev {
+        x1866: vec![],
+        x19b6: vec![],
+        tuf: enabled,
+    };
+    dbg!(&data);
+    dbus.proxies().led().set_leds_power(data, true)?;
+
+    let data = AuraPowerDev {
+        x1866: vec![],
+        x19b6: vec![],
+        tuf: disabled,
+    };
+    dbus.proxies().led().set_leds_power(data, false)?;
+
+    Ok(())
+}
+
+fn handle_led_power2(
+    dbus: &RogDbusClientBlocking,
+    supported: &LedSupportedFunctions,
+    power: &LedPowerCommand2,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if power.command().is_none() {
+        if !power.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", power.self_usage());
+        println!("Commands available");
+
+        if let Some(cmdlist) = LedPowerCommand2::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+            for command in commands.iter() {
+                println!("{}", command);
+            }
+        }
+
+        println!("\nHelp can also be requested on commands, e.g: boot --help");
+        return Ok(());
+    }
+
+    if let Some(pow) = power.command.as_ref() {
+        if pow.help_requested() {
+            println!("{}", pow.self_usage());
+            return Ok(());
+        }
+
+        if supported.prod_id != AuraDevice::X19B6 {
+            println!("This option applies only to keyboards with product ID 0x19b6")
+        }
+
+        let mut enabled: Vec<AuraDev19b6> = Vec::new();
+        let mut disabled: Vec<AuraDev19b6> = Vec::new();
+        let mut check = |e: Option<bool>, a: AuraDev19b6| {
+            if let Some(arg) = e {
+                if arg {
+                    enabled.push(a);
+                } else {
+                    disabled.push(a);
                 }
             }
-            _ => dbus
-                .proxies()
-                .led()
-                .set_led_mode(&<AuraEffect>::from(mode))?,
+        };
+
+        match pow {
+            aura_cli::SetAuraEnabled::Boot(arg) => {
+                check(arg.keyboard, AuraDev19b6::BootKeyb);
+                check(arg.logo, AuraDev19b6::BootLogo);
+                check(arg.lightbar, AuraDev19b6::BootBar);
+                check(arg.lid, AuraDev19b6::AwakeLid);
+            }
+            aura_cli::SetAuraEnabled::Sleep(arg) => {
+                check(arg.keyboard, AuraDev19b6::SleepKeyb);
+                check(arg.logo, AuraDev19b6::SleepLogo);
+                check(arg.lightbar, AuraDev19b6::SleepBar);
+                check(arg.lid, AuraDev19b6::SleepLid);
+            }
+            aura_cli::SetAuraEnabled::Awake(arg) => {
+                check(arg.keyboard, AuraDev19b6::AwakeKeyb);
+                check(arg.logo, AuraDev19b6::AwakeLogo);
+                check(arg.lightbar, AuraDev19b6::AwakeBar);
+                check(arg.lid, AuraDev19b6::AwakeLid);
+            }
+            aura_cli::SetAuraEnabled::Shutdown(arg) => {
+                check(arg.keyboard, AuraDev19b6::ShutdownKeyb);
+                check(arg.logo, AuraDev19b6::ShutdownLogo);
+                check(arg.lightbar, AuraDev19b6::ShutdownBar);
+                check(arg.lid, AuraDev19b6::ShutdownBar);
+            }
         }
-    }
 
-    if let Some(enable) = mode.awake_enable {
-        dbus.proxies().led().set_awake_enabled(enable)?;
-    }
+        if !enabled.is_empty() {
+            let data = AuraPowerDev {
+                tuf: vec![],
+                x1866: vec![],
+                x19b6: enabled,
+            };
+            dbus.proxies().led().set_leds_power(data, true)?;
+        }
 
-    if let Some(enable) = mode.sleep_enable {
-        dbus.proxies().led().set_sleep_enabled(enable)?;
+        if !disabled.is_empty() {
+            let data = AuraPowerDev {
+                tuf: vec![],
+                x1866: vec![],
+                x19b6: disabled,
+            };
+            dbus.proxies().led().set_leds_power(data, false)?;
+        }
     }
 
     Ok(())
 }
 
 fn handle_profile(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &PlatformProfileFunctions,
     cmd: &ProfileCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if !supported.fan_curves {
+    if !supported.platform_profile {
         println!("Profiles not supported by either this kernel or by the laptop.");
         return Err(ProfileError::NotSupported.into());
     }
 
-    println!("Warning: Profiles now depend on power-profiles-daemon v0.9+ which may not be in your install");
-    println!("         If you have unexpected behaviour or have only two profiles in your desktop control");
-    println!("         you need to manually install from https://gitlab.freedesktop.org/hadess/power-profiles-daemon");
-    println!("         Fedora and Arch distros will get the update soon...\n");
     if !cmd.next && !cmd.list && cmd.profile_set.is_none() && !cmd.profile_get {
         if !cmd.help {
             println!("Missing arg or command\n");
@@ -456,12 +688,13 @@ fn handle_profile(
 }
 
 fn handle_fan_curve(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &PlatformProfileFunctions,
     cmd: &FanCurveCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if !supported.fan_curves {
         println!("Fan-curves not supported by either this kernel or by the laptop.");
+        println!("This requires kernel 5.17 or the fan curve patch listed in the readme.");
         return Err(ProfileError::NotSupported.into());
     }
 
@@ -509,7 +742,7 @@ fn handle_fan_curve(
         if let Some(mut curve) = cmd.data.clone() {
             let fan = cmd.fan.unwrap_or_default();
             curve.set_fan(fan);
-            dbus.proxies().profile().set_fan_curve(curve, profile)?;
+            dbus.proxies().profile().set_fan_curve(profile, curve)?;
         }
     }
 
@@ -517,15 +750,17 @@ fn handle_fan_curve(
 }
 
 fn handle_bios_option(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &RogBiosSupportedFunctions,
     cmd: &BiosCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     {
-        if (cmd.dedicated_gfx_set.is_none()
-            && !cmd.dedicated_gfx_get
+        if (cmd.gpu_mux_mode_set.is_none()
+            && !cmd.gpu_mux_mode_get
             && cmd.post_sound_set.is_none()
-            && !cmd.post_sound_get)
+            && !cmd.post_sound_get
+            && cmd.panel_overdrive_set.is_none()
+            && !cmd.panel_overdrive_get)
             || cmd.help
         {
             println!("Missing arg or command\n");
@@ -536,35 +771,40 @@ fn handle_bios_option(
                 .collect();
 
             for line in usage.iter().filter(|line| {
-                line.contains("sound") && supported.post_sound_toggle
-                    || line.contains("GPU") && supported.dedicated_gfx_toggle
+                line.contains("sound") && supported.post_sound
+                    || line.contains("GPU") && supported.gpu_mux
+                    || line.contains("panel") && supported.panel_overdrive
             }) {
                 println!("{}", line);
             }
         }
 
         if let Some(opt) = cmd.post_sound_set {
-            dbus.proxies().rog_bios().set_post_sound(opt)?;
+            dbus.proxies().rog_bios().set_post_boot_sound(opt)?;
         }
         if cmd.post_sound_get {
-            let res = dbus.proxies().rog_bios().get_post_sound()? == 1;
+            let res = dbus.proxies().rog_bios().post_boot_sound()? == 1;
             println!("Bios POST sound on: {}", res);
         }
-        if let Some(opt) = cmd.dedicated_gfx_set {
+
+        if let Some(opt) = cmd.gpu_mux_mode_set {
             println!("Rebuilding initrd to include drivers");
-            dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
+            dbus.proxies()
+                .rog_bios()
+                .set_gpu_mux_mode(GpuMode::from_mux(opt))?;
             println!("The mode change is not active until you reboot, on boot the bios will make the required change");
-            if opt {
-                println!(
-                    "NOTE: on reboot your display manager will be forced to use Nvidia drivers"
-                );
-            } else {
-                println!("NOTE: after reboot you can then select regular graphics modes");
-            }
         }
-        if cmd.dedicated_gfx_get {
-            let res = dbus.proxies().rog_bios().get_dedicated_gfx()? == 1;
-            println!("Bios dedicated GPU on: {}", res);
+        if cmd.gpu_mux_mode_get {
+            let res = dbus.proxies().rog_bios().gpu_mux_mode()?;
+            println!("Bios GPU MUX: {:?}", res);
+        }
+
+        if let Some(opt) = cmd.panel_overdrive_set {
+            dbus.proxies().rog_bios().set_panel_od(opt)?;
+        }
+        if cmd.panel_overdrive_get {
+            let res = dbus.proxies().rog_bios().panel_od()?;
+            println!("Panel overdrive on: {}", res);
         }
     }
     Ok(())

daemon-user/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "daemon-user"
-version = "1.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 +14,19 @@ name = "asusd-user"
 path = "src/daemon.rs"
 
 [dependencies]
+dirs.workspace = true
+smol.workspace = true
+
 # serialisation
-serde = "^1.0"
-serde_json = "^1.0"
-serde_derive = "^1.0"
+serde.workspace = true
+serde_json.workspace = true
+serde_derive.workspace = true
 
 rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
-rog_supported = { path = "../rog-supported" }
+rog_platform = { path = "../rog-platform" }
 
-dirs = "3.0.1"
-
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"
+zbus.workspace = true
+zvariant.workspace = true
+zvariant_derive.workspace = true

daemon-user/src/ctrl_anime.rs

@@ -1,6 +1,6 @@
 use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
 use std::time::Duration;
 use std::{
@@ -15,6 +15,7 @@ use zbus::dbus_interface;
 use zvariant::ObjectPath;
 use zvariant_derive::Type;
 
+use crate::user_config::ConfigLoadSave;
 use crate::{error::Error, user_config::UserAnimeConfig};
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
@@ -66,14 +67,14 @@ pub enum TimeType {
 /// and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     do_early_return: Arc<AtomicBool>,
 }
 
 impl<'a> CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
@@ -91,12 +92,16 @@ impl<'a> CtrlAnimeInner<'static> {
         for action in self.sequences.iter() {
             match action {
                 ActionData::Animation(frames) => {
-                    rog_anime::run_animation(frames, self.do_early_return.clone(), &|output| {
+                    rog_anime::run_animation(frames, &|output| {
+                        if self.do_early_return.load(Ordering::Acquire) {
+                            return Ok(true); // Do safe exit
+                        }
                         self.client
                             .proxies()
                             .anime()
                             .write(output)
                             .map_err(|e| AnimeError::Dbus(format!("{}", e)))
+                            .map(|_| false)
                     })?;
                 }
                 ActionData::Image(image) => {
@@ -131,7 +136,7 @@ impl<'a> CtrlAnimeInner<'static> {
 
 pub struct CtrlAnime<'a> {
     config: Arc<Mutex<UserAnimeConfig>>,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
@@ -141,7 +146,7 @@ impl<'a> CtrlAnime<'static> {
     pub fn new(
         config: Arc<Mutex<UserAnimeConfig>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
@@ -152,12 +157,14 @@ impl<'a> CtrlAnime<'static> {
         })
     }
 
-    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+    pub async fn add_to_server(self, server: &mut zbus::Connection) {
         server
+            .object_server()
             .at(
                 &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
                 self,
             )
+            .await
             .map_err(|err| {
                 println!("CtrlAnime: add_to_server {}", err);
                 err
@@ -353,13 +360,13 @@ impl CtrlAnime<'static> {
     pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
         // Operations here need to be in specific order
         if on {
-            self.client.proxies().anime().set_on_off(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().set_on_off(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
         }
         Ok(())
     }

daemon-user/src/daemon.rs

@@ -1,67 +1,113 @@
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+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 zbus::{fdo, Connection};
+use std::{fs::OpenOptions, io::Read, path::PathBuf, sync::Arc};
+use zbus::Connection;
 
 use std::sync::atomic::AtomicBool;
 
+#[cfg(not(feature = "local_data"))]
+const DATA_DIR: &str = "/usr/share/rog-gui/";
+#[cfg(feature = "local_data")]
+const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("  user daemon v{}", rog_user::VERSION);
     println!("    rog-anime v{}", rog_anime::VERSION);
     println!("     rog-dbus v{}", rog_dbus::VERSION);
-    println!("rog-supported v{}", rog_supported::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
 
-    let (client, _) = RogDbusClient::new()?;
-    let supported = client.proxies().supported().get_supported_functions()?;
+    let (client, _) = RogDbusClientBlocking::new()?;
+    let supported = client.proxies().supported().supported_functions()?;
 
     let mut config = UserConfig::new();
-    config.load_config()?;
+    config.load()?;
 
-    let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
-    let anime = anime_config.create_anime()?;
-
-    let anime_config = Arc::new(Mutex::new(anime_config));
-
-    // Create server
-    let connection = Connection::new_session()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut server = zbus::ObjectServer::new(&connection);
+    let executor = Executor::new();
 
+    let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
     if supported.anime_ctrl.0 {
-        let early_return = Arc::new(AtomicBool::new(false));
-        // Inner behind mutex required for thread safety
-        let inner = Arc::new(Mutex::new(CtrlAnimeInner::new(
-            anime,
-            client,
-            early_return.clone(),
-        )?));
-        // Need new client object for dbus control part
-        let (client, _) = RogDbusClient::new()?;
-        let anime_control = CtrlAnime::new(anime_config, inner.clone(), client, early_return)?;
-        anime_control.add_to_server(&mut server);
-        // Thread using inner
-        let _anime_thread = thread::Builder::new()
-            .name("Anime User".into())
-            .spawn(move || loop {
-                if let Ok(inner) = inner.try_lock() {
-                    inner.run().ok();
-                }
-            })?;
-    }
+        if let Some(cfg) = config.active_anime {
+            let anime_type = get_anime_type()?;
+            let anime_config = UserAnimeConfig::load(cfg)?;
+            let anime = anime_config.create(anime_type)?;
+            let anime_config = Arc::new(Mutex::new(anime_config));
 
-    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 {
-        if let Err(err) = server.try_handle_next() {
-            println!("{}", err);
+                    // Inner behind mutex required for thread safety
+                    let inner = Arc::new(Mutex::new(
+                        CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let (client, _) = RogDbusClientBlocking::new().unwrap();
+                    let anime_control =
+                        CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                    anime_control.add_to_server(&mut connection).await;
+                    loop {
+                        if let Ok(inner) = inner.clone().try_lock() {
+                            inner.run().ok();
+                        }
+                    }
+                })
+                .detach();
         }
     }
+
+    // if supported.keyboard_led.per_key_led_mode {
+    if 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/user_config.rs

@@ -4,29 +4,22 @@ use std::{
     time::Duration,
 };
 
-use rog_anime::{ActionLoader, AnimTime, Fade, 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, Deserialize, Serialize)]
-pub struct UserAnimeConfig {
-    pub name: String,
-    pub anime: Vec<ActionLoader>,
-}
+pub trait ConfigLoadSave<T: DeserializeOwned + serde::Serialize> {
+    fn name(&self) -> String;
 
-impl UserAnimeConfig {
-    pub fn create_anime(&self) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new();
+    fn default_with_name(name: String) -> T;
 
-        for (idx, action) in self.anime.iter().enumerate() {
-            seq.insert(idx, action)?;
-        }
-
-        Ok(seq)
-    }
-
-    pub fn write(&self) -> Result<(), Error> {
+    fn write(&self) -> Result<(), Error>
+    where
+        Self: serde::Serialize,
+    {
         let mut path = if let Some(dir) = dirs::config_dir() {
             dir
         } else {
@@ -37,7 +30,7 @@ impl UserAnimeConfig {
         if !path.exists() {
             create_dir(path.clone())?;
         }
-        let name = self.name.clone();
+        let name = self.name();
         path.push(name + ".cfg");
 
         let mut file = OpenOptions::new()
@@ -51,7 +44,7 @@ impl UserAnimeConfig {
         Ok(())
     }
 
-    pub fn load_config(name: String) -> Result<UserAnimeConfig, Error> {
+    fn load(name: String) -> Result<T, Error> {
         let mut path = if let Some(dir) = dirs::config_dir() {
             dir
         } else {
@@ -75,14 +68,11 @@ impl UserAnimeConfig {
 
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
-                let default = UserAnimeConfig {
-                    name,
-                    ..Default::default()
-                };
+                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::<UserAnimeConfig>(&buf) {
+            } else if let Ok(data) = serde_json::from_str::<T>(&buf) {
                 return Ok(data);
             }
         }
@@ -90,6 +80,37 @@ impl UserAnimeConfig {
     }
 }
 
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UserAnimeConfig {
+    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 {
@@ -151,20 +172,91 @@ impl Default for UserAnimeConfig {
     }
 }
 
+#[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()
+    }
+
+    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_string(),
+            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: String,
+    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: "anime-default".to_string(),
+            active_anime: Some("anime-default".to_string()),
+            active_aura: Some("aura-default".to_string()),
         }
     }
 
-    pub fn load_config(&mut self) -> Result<(), Error> {
+    pub fn load(&mut self) -> Result<(), Error> {
         let mut path = if let Some(dir) = dirs::config_dir() {
             dir
         } else {
@@ -192,6 +284,7 @@ impl UserConfig {
                 file.write_all(json.as_bytes())?;
             } else if let Ok(data) = serde_json::from_str::<UserConfig>(&buf) {
                 self.active_anime = data.active_anime;
+                self.active_aura = data.active_aura;
                 return Ok(());
             }
         }

daemon/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "daemon"
-version = "4.0.6"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2018"
+edition = "2021"
 
 [lib]
 name = "daemon"
@@ -18,28 +18,30 @@ name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
-rog_anime = { path = "../rog-anime" }
-rog_aura = { path = "../rog-aura" }
-rog_supported = { path = "../rog-supported" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
+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"
-env_logger = "^0.8"
+log.workspace = true
+env_logger.workspace = true
 
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = { version = "^2.6" }
-logind-zbus = "^0.7.1"
+zbus.workspace = true
+zvariant.workspace = true
+logind-zbus.workspace = true
 
 # serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "^0.5.8"
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+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
+
+concat-idents.workspace = true

daemon/src/config.rs

@@ -2,19 +2,23 @@ use log::{error, warn};
 use serde_derive::{Deserialize, Serialize};
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
+use std::path::PathBuf;
 
 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Default)]
+#[serde(default)]
 pub struct Config {
     /// Save charge limit for restoring on boot
     pub bat_charge_limit: u8,
+    pub panel_od: bool,
 }
 
 impl Config {
     fn new() -> Self {
         Config {
             bat_charge_limit: 100,
+            panel_od: false,
         }
     }
 
@@ -24,8 +28,8 @@ impl Config {
             .read(true)
             .write(true)
             .create(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
+            .open(&PathBuf::from(CONFIG_PATH))
+            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
         let mut buf = String::new();
         let config;
         if let Ok(read_len) = file.read_to_string(&mut buf) {
@@ -57,7 +61,7 @@ impl 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) {

daemon/src/ctrl_anime/config.rs

@@ -1,7 +1,7 @@
 use crate::VERSION;
 use log::{error, info, warn};
-use rog_anime::Fade;
 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};
@@ -80,28 +80,32 @@ pub struct AnimeConfigCached {
 }
 
 impl AnimeConfigCached {
-    pub fn init_from_config(&mut self, config: &AnimeConfig) -> Result<(), AnimeError> {
+    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.iter() {
-            sys.push(ActionData::from_anime_action(ani)?);
+            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.iter() {
-            boot.push(ActionData::from_anime_action(ani)?);
+            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.iter() {
-            wake.push(ActionData::from_anime_action(ani)?);
+            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.iter() {
-            shutdown.push(ActionData::from_anime_action(ani)?);
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
         }
         self.shutdown = shutdown;
         Ok(())
@@ -153,17 +157,20 @@ impl AnimeConfig {
             if read_len == 0 {
                 return AnimeConfig::create_default(&mut file);
             } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
+                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 config = data.into_current();
+                    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 config = data.into_current();
+                    let mut config = data.into_current();
                     config.write();
                     info!("Updated config version to: {}", VERSION);
+                    Self::clamp_config_brightness(&mut config);
                     return config;
                 }
                 warn!(
@@ -182,6 +189,16 @@ impl AnimeConfig {
         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 {

daemon/src/ctrl_anime/mod.rs

@@ -1,45 +1,31 @@
 pub mod config;
-pub mod zbus;
-
-use ::zbus::Connection;
-use log::{error, info, warn};
-use logind_zbus::ManagerProxy;
-use rog_anime::{
-    error::AnimeError,
-    usb::{
-        pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on, pkts_for_init, PROD_ID,
-        VENDOR_ID,
-    },
-    ActionData, AnimeDataBuffer, AnimePacketType, ANIME_DATA_LEN,
-};
-use rog_supported::AnimeSupportedFunctions;
-use rusb::{Device, DeviceHandle};
-use std::{
-    cell::RefCell,
-    error::Error,
-    sync::{Arc, Mutex},
-    thread::sleep,
-};
-use std::{
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
-
-use crate::{error::RogError, GetSupported};
+/// 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(CtrlAnime::get_device(VENDOR_ID, PROD_ID).is_ok())
+        AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
     }
 }
 
 pub struct CtrlAnime {
-    _node: String,
-    handle: RefCell<DeviceHandle<rusb::GlobalContext>>,
+    node: USBRaw,
+    anime_type: AnimeType,
     cache: AnimeConfigCached,
     config: AnimeConfig,
     // set to force thread to exit
@@ -51,83 +37,26 @@ pub struct CtrlAnime {
 impl CtrlAnime {
     #[inline]
     pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
-        let node = Self::find_node("193b")?;
-        let device = Self::get_dev_handle()?;
+        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)?;
+        cache.init_from_config(&config, anime_type)?;
 
         let ctrl = CtrlAnime {
-            _node: node,
-            handle: RefCell::new(device),
+            node,
+            anime_type,
             cache,
             config,
             thread_exit: Arc::new(AtomicBool::new(false)),
             thread_running: Arc::new(AtomicBool::new(false)),
         };
-        ctrl.do_initialization();
+        ctrl.do_initialization()?;
 
         Ok(ctrl)
     }
-
-    fn find_node(id_product: &str) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("usb").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(attr) = device.attribute_value("idProduct") {
-                if attr == id_product {
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for AniMe control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        Err(RogError::MissingFunction(
-            "ASUS AniMe device node not found".into(),
-        ))
-    }
-
-    fn get_dev_handle() -> Result<DeviceHandle<rusb::GlobalContext>, Box<dyn Error>> {
-        // We don't expect this ID to ever change
-        let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
-
-        let mut device = device.open()?;
-        device.reset()?;
-
-        device.set_auto_detach_kernel_driver(true).map_err(|err| {
-            error!("Auto-detach kernel driver failed: {}", err);
-            err
-        })?;
-
-        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {}", err);
-            err
-        })?;
-
-        Ok(device)
-    }
-
-    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
-        for device in rusb::devices()?.iter() {
-            let device_desc = device.device_descriptor()?;
-            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return Ok(device);
-            }
-        }
-        Err(rusb::Error::NoDevice)
-    }
+    // 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.
@@ -139,74 +68,84 @@ impl CtrlAnime {
             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 system thread started");
+                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.
-                loop {
-                    if let Ok(lock) = inner.try_lock() {
-                        thread_exit = lock.thread_exit.clone();
-                        thread_running = lock.thread_running.clone();
-                        // Make any running loop exit first
-                        thread_exit.store(true, Ordering::SeqCst);
-                        break;
-                    }
+                while thread_running.load(Ordering::SeqCst) {
+                    // Make any running loop exit first
+                    thread_exit.store(true, Ordering::SeqCst);
                 }
 
-                loop {
-                    // wait for other threads to set not running so we know they exited
-                    if !thread_running.load(Ordering::SeqCst) {
-                        thread_exit.store(false, Ordering::SeqCst);
-                        info!("AniMe forced a thread to exit");
-                        break;
-                    }
-                }
+                info!("AniMe no previous system thread running (now)");
+                thread_exit.store(false, Ordering::SeqCst);
 
                 'main: loop {
-                    if thread_exit.load(Ordering::SeqCst) {
-                        break 'main;
-                    }
+                    thread_running.store(true, Ordering::SeqCst);
                     for action in actions.iter() {
+                        if thread_exit.load(Ordering::SeqCst) {
+                            break 'main;
+                        }
                         match action {
                             ActionData::Animation(frames) => {
-                                if let Err(err) = rog_anime::run_animation(
-                                    frames,
-                                    thread_exit.clone(),
-                                    &|frame| {
-                                        inner
-                                            .try_lock()
-                                            .map(|lock| lock.write_data_buffer(frame))
-                                            .map_err(|err| {
-                                                warn!("rog_anime::run_animation: {}", err);
-                                                AnimeError::NoFrames
-                                            })
-                                    },
-                                ) {
-                                    warn!("rog_anime::run_animation: {}", err);
+                                if let Err(err) = rog_anime::run_animation(frames, &|frame| {
+                                    if thread_exit.load(Ordering::Acquire) {
+                                        info!("rog-anime: frame-loop was asked to exit");
+                                        return Ok(true); // Do safe exit
+                                    }
+                                    inner
+                                        .try_lock()
+                                        .map(|lock| {
+                                            lock.write_data_buffer(frame)
+                                                .map_err(|err| {
+                                                    warn!(
+                                                        "rog_anime::run_animation:callback {}",
+                                                        err
+                                                    );
+                                                })
+                                                .ok();
+                                            false // Don't exit yet
+                                        })
+                                        .map(Ok)
+                                        .unwrap_or_else(|| {
+                                            warn!("rog_anime::run_animation:callback failed");
+                                            Err(AnimeError::NoFrames)
+                                        })
+                                }) {
+                                    warn!("rog_anime::run_animation:Animation {}", err);
                                     break 'main;
                                 };
-
-                                if thread_exit.load(Ordering::SeqCst) {
-                                    break 'main;
-                                }
                             }
                             ActionData::Image(image) => {
                                 once = false;
-                                if let Ok(lock) = inner.try_lock() {
+                                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),
@@ -216,17 +155,27 @@ impl CtrlAnime {
                             ActionData::Matrix => {}
                         }
                     }
+                    if thread_exit.load(Ordering::SeqCst) {
+                        break 'main;
+                    }
                     if once || actions.is_empty() {
                         break 'main;
                     }
                 }
                 // Clear the display on exit
-                if let Ok(lock) = inner.try_lock() {
-                    let data = AnimeDataBuffer::from_vec([0u8; ANIME_DATA_LEN].to_vec());
-                    lock.write_data_buffer(data);
+                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_exit.store(false, Ordering::SeqCst);
                 thread_running.store(false, Ordering::SeqCst);
                 info!("AniMe system thread exited");
             })
@@ -234,169 +183,28 @@ impl CtrlAnime {
             .ok();
     }
 
-    fn write_bytes(&self, message: &[u8]) {
-        // if let Ok(mut file) = OpenOptions::new().write(true).open(&self.node) {
-        //     println!("write: {:02x?}", &message);
-        //     return file
-        //         .write_all(message).unwrap();
-        // }
-        let mut error = false;
-
-        match self.handle.borrow().write_control(
-            0x21,  // request_type
-            0x09,  // request
-            0x35e, // value
-            0x00,  // index
-            message,
-            Duration::from_millis(200),
-        ) {
-            Ok(_) => {}
-            Err(err) => match err {
-                rusb::Error::Timeout => {}
-                _ => {
-                    error = true;
-                    error!("Failed to write to led interrupt: {}", err);
-                }
-            },
-        }
-
-        if error {
-            warn!("Will attempt to get AniMe device handle again");
-            match Self::get_dev_handle() {
-                Ok(dev) => {
-                    self.handle.replace(dev);
-                }
-                Err(err) => {
-                    error!("Failed to get AniMe device: {}", err);
-                }
-            }
-        }
-    }
-
     /// Write only a data packet. This will modify the leds brightness using the
     /// global brightness set in config.
-    fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) {
-        for led in buffer.get_mut()[7..].iter_mut() {
+    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::from(buffer);
+        let data = AnimePacketType::try_from(buffer)?;
         for row in data.iter() {
-            self.write_bytes(row);
+            self.node.write_bytes(row)?;
         }
-        self.write_bytes(&pkt_for_flush());
+        self.node.write_bytes(&pkt_for_flush())?;
+        Ok(())
     }
 
-    fn do_initialization(&self) {
+    fn do_initialization(&self) -> Result<(), RogError> {
         let pkts = pkts_for_init();
-        self.write_bytes(&pkts[0]);
-        self.write_bytes(&pkts[1]);
-    }
-}
-
-pub struct CtrlAnimeTask<'a> {
-    inner: Arc<Mutex<CtrlAnime>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
-}
-
-impl<'a> CtrlAnimeTask<'a> {
-    pub fn new(inner: Arc<Mutex<CtrlAnime>>) -> Self {
-        let connection =
-            Connection::new_system().expect("CtrlAnimeTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlAnimeTask could not create ManagerProxy");
-
-        let c1 = inner.clone();
-        // Run this action when the system starts shutting down
-        manager
-            .connect_prepare_for_shutdown(move |shutdown| {
-                if shutdown {
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.shutdown.clone(), false);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    // wait a fraction for things to wake up properly
-                    std::thread::sleep(Duration::from_millis(100));
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.wake.clone(), true);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
-    }
-}
-
-impl<'a> crate::CtrlTask for CtrlAnimeTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(mut lock) = self.inner.try_lock() {
-            // Refresh the config and cache incase the user has edited it
-            let config = AnimeConfig::load();
-            lock.cache
-                .init_from_config(&config)
-                .map_err(|err| {
-                    warn!("CtrlAnimeTask: do_task {}", err);
-                    err
-                })
-                .ok();
-        }
-
-        // Check for signals on each task iteration, this will run the callbacks
-        // if any signal is recieved
-        self.manager.next_signal()?;
-        Ok(())
-    }
-}
-
-pub struct CtrlAnimeReloader(pub Arc<Mutex<CtrlAnime>>);
-
-impl crate::Reloadable for CtrlAnimeReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(lock) = self.0.try_lock() {
-            lock.write_bytes(&pkt_for_set_on(lock.config.awake_enabled));
-            lock.write_bytes(&pkt_for_apply());
-            lock.write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled));
-            lock.write_bytes(&pkt_for_apply());
-
-            let action = lock.cache.boot.clone();
-            CtrlAnime::run_thread(self.0.clone(), action, true);
-        }
+        self.node.write_bytes(&pkts[0])?;
+        self.node.write_bytes(&pkts[1])?;
         Ok(())
     }
 }

daemon/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,216 @@
+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 || 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;
+
+        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_anime/zbus.rs

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

daemon/src/ctrl_aura/config.rs

@@ -1,74 +1,186 @@
-use crate::laptops::LaptopLedData;
-use log::{error, info, warn};
-use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
+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;
+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";
 
-#[derive(Deserialize, Serialize)]
-pub struct AuraConfigV320 {
-    pub brightness: u32,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
+/// 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 AuraConfigV320 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: <LedBrightness>::from(self.brightness),
-            current_mode: self.current_mode,
-            builtins: self.builtins,
-            multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AuraConfigV352 {
-    pub brightness: LedBrightness,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl AuraConfigV352 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: self.brightness,
-            current_mode: self.current_mode,
-            builtins: self.builtins,
-            multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
+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<AuraMultiZone>,
-    pub awake_enabled: bool,
-    pub sleep_anim_enabled: bool,
+    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.iter() {
+            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,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
+            multizone_on: false,
+            enabled,
         }
     }
 }
@@ -94,16 +206,6 @@ impl AuraConfig {
             } else {
                 if let Ok(data) = serde_json::from_str(&buf) {
                     return data;
-                } else if let Ok(data) = serde_json::from_str::<AuraConfigV320>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated AuraConfig version");
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<AuraConfigV352>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated AuraConfig version");
-                    return config;
                 }
                 warn!(
                     "Could not deserialise {}.\nWill rename to {}-old and recreate config",
@@ -129,6 +231,27 @@ impl AuraConfig {
             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
@@ -148,7 +271,7 @@ impl AuraConfig {
             if l == 0 {
                 warn!("File is empty {}", AURA_CONFIG_PATH);
             } else {
-                let x: AuraConfig = serde_json::from_str(&buf)
+                let x = serde_json::from_str(&buf)
                     .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
                 *self = x;
             }
@@ -162,115 +285,142 @@ impl AuraConfig {
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
 
-    /// Multipurpose, will accept AuraEffect with zones and put in the correct store
+    /// 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;
         match effect.zone() {
             AuraZone::None => {
                 self.builtins.insert(*effect.mode(), effect);
+                self.multizone_on = false;
             }
             _ => {
                 if let Some(multi) = self.multizone.as_mut() {
-                    multi.set(effect)
+                    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; 4]> {
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
         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());
-            }
+            return multi.get(&aura_type).map(|v| v.as_slice());
         }
         None
     }
 }
 
-#[derive(Deserialize, Serialize)]
-pub struct AuraMultiZone {
-    static_: [AuraEffect; 4],
-    breathe: [AuraEffect; 4],
-}
+#[cfg(test)]
+mod tests {
+    use super::AuraConfig;
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
 
-impl AuraMultiZone {
-    pub fn set(&mut self, effect: AuraEffect) {
-        if effect.mode == AuraModeNum::Static {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.static_[0] = effect,
-                AuraZone::Two => self.static_[1] = effect,
-                AuraZone::Three => self.static_[2] = effect,
-                AuraZone::Four => self.static_[3] = effect,
-            }
-        } else if effect.mode == AuraModeNum::Breathe {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.breathe[0] = effect,
-                AuraZone::Two => self.breathe[1] = effect,
-                AuraZone::Three => self.breathe[2] = effect,
-                AuraZone::Four => self.breathe[3] = effect,
-            }
-        }
+    #[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));
     }
 
-    pub fn static_(&self) -> &[AuraEffect; 4] {
-        &self.static_
-    }
+    #[test]
+    fn set_multizone_multimode_config() {
+        let mut config = AuraConfig::default();
 
-    pub fn breathe(&self) -> &[AuraEffect; 4] {
-        &self.breathe
-    }
-}
-
-impl Default for AuraMultiZone {
-    fn default() -> Self {
-        Self {
-            static_: [
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-            breathe: [
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-        }
+        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

@@ -1,44 +1,48 @@
-// Only these two packets must be 17 bytes
-static KBD_BRIGHT_PATH: &str = "/sys/class/leds/asus::kbd_backlight/brightness";
-
 use crate::{
     error::RogError,
     laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-    CtrlTask,
 };
 use log::{info, warn};
-use logind_zbus::ManagerProxy;
 use rog_aura::{
-    usb::{
-        LED_APPLY, LED_AWAKE_OFF_SLEEP_OFF, LED_AWAKE_OFF_SLEEP_ON, LED_AWAKE_ON_SLEEP_OFF,
-        LED_AWAKE_ON_SLEEP_ON, LED_SET,
-    },
-    AuraEffect, LedBrightness, LED_MSG_LEN,
+    usb::{AuraDevice, LED_APPLY, LED_SET},
+    AuraEffect, KeyColourArray, LedBrightness, PerKeyRaw, LED_MSG_LEN,
 };
-use rog_supported::LedSupportedFunctions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::{fs::OpenOptions, thread::spawn};
-use zbus::Connection;
+use 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;
+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 multizone_led_mode = false;
-        let per_key_led_mode = false;
         let laptop = LaptopLedData::get_data();
         let stock_led_modes = laptop.standard;
+        let multizone_led_mode = laptop.multizone;
+        let per_key_led_mode = laptop.per_key;
+
+        let mut prod_id = AuraDevice::Unknown;
+        for prod in ASUS_KEYBOARD_DEVICES.iter() {
+            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 {
-            brightness_set: CtrlKbdLed::get_kbd_bright_path().is_some(),
+            prod_id,
+            brightness_set: rgb.is_ok(),
             stock_led_modes,
             multizone_led_mode,
             per_key_led_mode,
@@ -46,199 +50,84 @@ impl GetSupported for CtrlKbdLed {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, PartialOrd)]
+pub enum LEDNode {
+    KbdLed(KeyboardLed),
+    Rog(HidRaw),
+    None,
+}
+
 pub struct CtrlKbdLed {
-    pub led_node: Option<String>,
-    pub bright_node: String,
+    // 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,
 }
 
-pub struct CtrlKbdLedTask<'a> {
-    inner: Arc<Mutex<CtrlKbdLed>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
-}
-
-impl<'a> CtrlKbdLedTask<'a> {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        let connection =
-            Connection::new_system().expect("CtrlKbdLedTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlKbdLedTask could not create ManagerProxy");
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    let c1 = c1.clone();
-                    spawn(move || {
-                        // wait a fraction for things to wake up properly
-                        //std::thread::sleep(Duration::from_millis(100));
-                        loop {
-                            if let Ok(ref mut lock) = c1.try_lock() {
-                                lock.set_brightness(lock.config.brightness).ok();
-                                break;
-                            }
-                        }
-                    });
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
-    }
-
-    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&lock.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&lock.bright_node).into(), err)
-                }
-                _ => RogError::Path((&lock.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if lock.config.brightness != num.into() {
-                lock.config.read();
-                lock.config.brightness = num.into();
-                lock.config.write();
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLed)
-    }
-}
-
-impl<'a> CtrlTask for CtrlKbdLedTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        self.manager.next_signal()?;
-        if let Ok(ref mut lock) = self.inner.try_lock() {
-            return Self::update_config(lock);
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedReloader(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl crate::Reloadable for CtrlKbdLedReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            let current = ctrl.config.current_mode;
-            if let Some(mode) = ctrl.config.builtins.get(&current).cloned() {
-                ctrl.do_command(mode).ok();
-            }
-
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl CtrlKbdLedZbus {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        Self(inner)
-    }
-}
-
 impl CtrlKbdLed {
-    #[inline]
     pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
-        // TODO: return error if *all* nodes are None
+        let mut led_prod = None;
         let mut led_node = None;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            match Self::find_led_node(prod) {
+            match HidRaw::new(prod) {
                 Ok(node) => {
+                    led_prod = Some(prod.to_string());
                     led_node = Some(node);
+                    info!("Looked for keyboard controller 0x{prod}: Found");
                     break;
                 }
-                Err(err) => warn!("led_node: {}", err),
+                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
             }
         }
 
-        let bright_node = Self::get_kbd_bright_path();
+        let rgb_led = KeyboardLed::new()?;
 
-        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 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);
         }
 
-        if bright_node.is_none() {
-            return Err(RogError::MissingFunction(
-                "No brightness control, you may require a v5.11 series kernel or newer".into(),
-            ));
-        }
+        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,
-            bright_node: bright_node.unwrap(), // If was none then we already returned above
+            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)
     }
 
-    fn get_kbd_bright_path() -> Option<String> {
-        if Path::new(KBD_BRIGHT_PATH).exists() {
-            return Some(KBD_BRIGHT_PATH.to_string());
-        }
-        None
-    }
-
     pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.bright_node)
-            .map_err(|err| match err.kind() {
-                std::io::ErrorKind::NotFound => {
-                    RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                }
-                _ => RogError::Path((&self.bright_node).into(), err),
-            })?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(buf[0])
+        self.kd_brightness
+            .get_brightness()
+            .map_err(RogError::Platform)
     }
 
     pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
-        let path = Path::new(&self.bright_node);
-        let mut file =
-            OpenOptions::new()
-                .write(true)
-                .open(&path)
-                .map_err(|err| match err.kind() {
-                    std::io::ErrorKind::NotFound => {
-                        RogError::MissingLedBrightNode((&self.bright_node).into(), err)
-                    }
-                    _ => RogError::Path((&self.bright_node).into(), err),
-                })?;
-        file.write_all(&[brightness.as_char_code()])
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        Ok(())
+        self.kd_brightness
+            .set_brightness(brightness as u8)
+            .map_err(RogError::Platform)
     }
 
     pub fn next_brightness(&mut self) -> Result<(), RogError> {
@@ -263,112 +152,83 @@ impl CtrlKbdLed {
         self.set_brightness(self.config.brightness)
     }
 
-    /// Set if awake/on LED active, and/or sleep animation active
-    pub(super) fn set_states_enabled(&self, awake: bool, sleep: bool) -> Result<(), RogError> {
-        let bytes = if awake && sleep {
-            LED_AWAKE_ON_SLEEP_ON
-        } else if awake && !sleep {
-            LED_AWAKE_ON_SLEEP_OFF
-        } else if !awake && sleep {
-            LED_AWAKE_OFF_SLEEP_ON
-        } else if !awake && !sleep {
-            LED_AWAKE_OFF_SLEEP_OFF
-        } else {
-            LED_AWAKE_ON_SLEEP_ON
-        };
-        self.write_bytes(&bytes)?;
-        self.write_bytes(&LED_SET)?;
-        // Changes won't persist unless apply is set
-        self.write_bytes(&LED_APPLY)?;
+    /// 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(())
     }
 
-    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
+    /// Set an Aura effect if the effect mode or zone is supported.
     ///
-    /// 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);
+    /// 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(())
     }
 
-    #[inline]
+    /// 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
@@ -394,26 +254,256 @@ impl CtrlKbdLed {
             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;
-            }
+            // if self.config.builtins.contains_key(&next) {
+            self.config.current_mode = next;
+            self.write_current_config_mode()?;
+            // }
             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);
+    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);
         }
-        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(())
     }
 }
+
+#[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: "".into(),
+            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: "".into(),
+            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: "".into(),
+            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

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

daemon/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,320 @@
+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 || loop {
+                if let Some(lock) = inner1.try_lock() {
+                    load_save(true, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner2.try_lock() {
+                    load_save(false, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner3.try_lock() {
+                    load_save(true, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner4.try_lock() {
+                    load_save(false, lock);
+                    break;
+                }
+            },
+        )
+        .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_aura/zbus.rs

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

daemon/src/ctrl_charge.rs

@@ -1,132 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
-use rog_supported::ChargeSupportedFunctions;
-use std::fs::OpenOptions;
-use std::io::Write;
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
-
-static BAT_CHARGE_PATH0: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
-static BAT_CHARGE_PATH1: &str = "/sys/class/power_supply/BAT1/charge_control_end_threshold";
-static BAT_CHARGE_PATH2: &str = "/sys/class/power_supply/BAT2/charge_control_end_threshold";
-
-impl GetSupported for CtrlCharge {
-    type A = ChargeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        ChargeSupportedFunctions {
-            charge_level_set: CtrlCharge::get_battery_path().is_ok(),
-        }
-    }
-}
-
-pub struct CtrlCharge {
-    config: Arc<Mutex<Config>>,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlCharge {
-    pub fn set_limit(&mut self, limit: u8) -> Result<(), RogError> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit));
-        }
-        if let Ok(mut config) = self.config.try_lock() {
-            self.set(limit, &mut config)
-                .map_err(|err| {
-                    warn!("CtrlCharge: set_limit {}", err);
-                    err
-                })
-                .ok();
-            self.notify_charge(limit)
-                .map_err(|err| {
-                    warn!("CtrlCharge: set_limit {}", err);
-                    err
-                })
-                .ok();
-        }
-        Ok(())
-    }
-
-    pub fn limit(&self) -> i8 {
-        if let Ok(config) = self.config.try_lock() {
-            return config.bat_charge_limit as i8;
-        }
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
-}
-
-impl crate::ZbusAdd for CtrlCharge {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Charge"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlCharge: add_to_server {}", err);
-                err
-            })
-            .ok();
-    }
-}
-
-impl crate::Reloadable for CtrlCharge {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.try_lock() {
-            config.read();
-            self.set(config.bat_charge_limit, &mut config)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlCharge {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        CtrlCharge::get_battery_path()?;
-        Ok(CtrlCharge { config })
-    }
-
-    fn get_battery_path() -> Result<&'static str, RogError> {
-        if Path::new(BAT_CHARGE_PATH0).exists() {
-            Ok(BAT_CHARGE_PATH0)
-        } else if Path::new(BAT_CHARGE_PATH1).exists() {
-            Ok(BAT_CHARGE_PATH1)
-        } else if Path::new(BAT_CHARGE_PATH2).exists() {
-            Ok(BAT_CHARGE_PATH2)
-        } else {
-            Err(RogError::MissingFunction(
-                "Charge control not available, you may require a v5.8.10 series kernel or newer"
-                    .into(),
-            ))
-        }
-    }
-
-    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit));
-        }
-
-        let path = Self::get_battery_path()?;
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-        file.write_all(limit.to_string().as_bytes())
-            .map_err(|err| RogError::Write(path.into(), err))?;
-        info!("Battery charge limit: {}", limit);
-
-        config.read();
-        config.bat_charge_limit = limit;
-        config.write();
-
-        Ok(())
-    }
-}

daemon/src/ctrl_platform.rs

@@ -0,0 +1,375 @@
+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);
+    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 || {},
+            move || {
+                info!("CtrlRogBios reloading panel_od");
+                if let Some(lock) = platform1.config.try_lock() {
+                    if platform1.platform.has_panel_od() {
+                        platform1
+                            .set_panel_overdrive(lock.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: set_limit {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move || {},
+            move || {
+                info!("CtrlRogBios reloading panel_od");
+                if let Some(lock) = platform2.config.try_lock() {
+                    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?;
+        self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+
+        Ok(())
+    }
+}

daemon/src/ctrl_power.rs

@@ -0,0 +1,239 @@
+use crate::systemd::{do_systemd_unit_action, SystemdUnitAction};
+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::power::AsusPower;
+use rog_platform::supported::ChargeSupportedFunctions;
+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 || {},
+            move || {
+                info!("CtrlCharge reloading charge limit");
+                if let Some(lock) = power1.config.try_lock() {
+                    power1
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+                }
+                if let Ok(value) = power1.power.get_online() {
+                    let action = if value == 1 {
+                        SystemdUnitAction::Restart
+                    } else {
+                        SystemdUnitAction::Stop
+                    };
+                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                    }
+                }
+            },
+            move || {},
+            move || {
+                info!("CtrlCharge reloading charge limit");
+                if let Some(lock) = power2.config.try_lock() {
+                    power2
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+                }
+                if let Ok(value) = power2.power.get_online() {
+                    let action = if value == 1 {
+                        SystemdUnitAction::Restart
+                    } else {
+                        SystemdUnitAction::Stop
+                    };
+                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                    }
+                }
+            },
+        )
+        .await;
+
+        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;
+                        let action = if value == 1 {
+                            SystemdUnitAction::Restart
+                        } else {
+                            SystemdUnitAction::Stop
+                        };
+                        if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                            info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                        }
+
+                        Self::notify_mains_online(&signal_ctxt, value == 1)
+                            .await
+                            .unwrap();
+                    }
+                }
+                // 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(())
+    }
+}

daemon/src/ctrl_profiles/config.rs

@@ -23,17 +23,6 @@ impl ProfileConfig {
         }
     }
 
-    pub fn set_defaults_and_save(&mut self) {
-        self.active_profile = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-        if let Ok(res) = FanCurveProfiles::is_supported() {
-            if res {
-                let curves = FanCurveProfiles::default();
-                self.fan_curves = Some(curves);
-            }
-        }
-        self.write();
-    }
-
     pub fn load(config_path: String) -> Self {
         let mut file = OpenOptions::new()
             .read(true)
@@ -46,7 +35,6 @@ impl ProfileConfig {
         if let Ok(read_len) = file.read_to_string(&mut buf) {
             if read_len == 0 {
                 config = Self::new(config_path);
-                config.set_defaults_and_save();
             } else if let Ok(data) = toml::from_str(&buf) {
                 config = data;
                 config.config_path = config_path;
@@ -63,11 +51,9 @@ impl ProfileConfig {
                     )
                 });
                 config = Self::new(config_path);
-                config.set_defaults_and_save();
             }
         } else {
             config = Self::new(config_path);
-            config.set_defaults_and_save();
         }
         config
     }

daemon/src/ctrl_profiles/controller.rs

@@ -1,16 +1,16 @@
-use std::sync::{Arc, Mutex};
-
 use crate::error::RogError;
-use crate::{CtrlTask, GetSupported};
+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 rog_supported::PlatformProfileFunctions;
 
 use super::config::ProfileConfig;
 
 pub struct CtrlPlatformProfile {
     pub config: ProfileConfig,
+    pub platform: AsusPlatform,
 }
 
 impl GetSupported for CtrlPlatformProfile {
@@ -18,13 +18,7 @@ impl GetSupported for CtrlPlatformProfile {
 
     fn get_supported() -> Self::A {
         if !Profile::is_platform_profile_supported() {
-            warn!(
-                r#"
-platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.
-To enable profile support you require a kernel with the following patch applied:
-https://lkml.org/lkml/2021/8/18/1022
-"#
-            );
+            warn!("platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.");
         }
 
         let res = FanCurveProfiles::is_supported();
@@ -34,14 +28,7 @@ https://lkml.org/lkml/2021/8/18/1022
         };
 
         if !fan_curve_supported {
-            info!(
-                r#"
-fan curves kernel interface not found, your laptop does not support this, or the interface is missing.
-To enable fan-curve support you require a kernel with the following patch applied:
-https://lkml.org/lkml/2021/8/20/232
-Please note that as of 24/08/2021 this is not final.
-"#
-            );
+            info!("fan curves kernel interface not found, your laptop does not support this, or the interface is missing.");
         }
 
         PlatformProfileFunctions {
@@ -51,31 +38,33 @@ Please note that as of 24/08/2021 this is not final.
     }
 }
 
-impl crate::Reloadable for CtrlPlatformProfile {
-    /// Fetch the active profile and use that to set all related components up
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = &mut self.config.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                // There is a possibility that the curve was default zeroed, so this call initialises
-                // the data from system read and we need to save it after
-                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
-                self.config.write();
-            }
-        }
-        Ok(())
-    }
-}
-
 impl CtrlPlatformProfile {
     pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
-        if Profile::is_platform_profile_supported() {
+        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(CtrlPlatformProfile { config });
+            return Ok(controller);
         }
 
         Err(ProfileError::NotSupported.into())
@@ -125,27 +114,3 @@ impl CtrlPlatformProfile {
         Ok(())
     }
 }
-
-pub struct CtrlProfileTask {
-    ctrl: Arc<Mutex<CtrlPlatformProfile>>,
-}
-
-impl CtrlProfileTask {
-    pub fn new(ctrl: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { ctrl }
-    }
-}
-
-impl CtrlTask for CtrlProfileTask {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(ref mut lock) = self.ctrl.try_lock() {
-            let new_profile = Profile::get_active_profile().unwrap();
-            if new_profile != lock.config.active_profile {
-                lock.config.active_profile = new_profile;
-                lock.write_profile_curve_to_platform()?;
-                lock.save_config();
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/mod.rs

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

daemon/src/ctrl_profiles/trait_impls.rs

@@ -0,0 +1,246 @@
+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_string(),
+        ))
+    }
+
+    /// 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().to_vec());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+    }
+
+    /// 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_string()))
+        }
+    }
+
+    /// 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_string()))
+    }
+
+    /// 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_string()));
+        }
+        ctrl.write_profile_curve_to_platform()
+            .map_err(|e| warn!("Profile::set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be read
+    /// only for the currently active profile.
+    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()?;
+
+        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(&signal_ctxt.clone(), 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_profiles/zbus.rs

@@ -1,189 +0,0 @@
-use log::warn;
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::fan_curve_set::FanCurveSet;
-use rog_profiles::Profile;
-
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::{dbus_interface, fdo::Error};
-use zvariant::ObjectPath;
-
-use super::controller::CtrlPlatformProfile;
-
-static UNSUPPORTED_MSG: &str =
-    "Fan curves are not supported on this laptop or you require a patched kernel";
-
-pub struct ProfileZbus {
-    inner: Arc<Mutex<CtrlPlatformProfile>>,
-}
-
-impl ProfileZbus {
-    pub fn new(inner: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { inner }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl ProfileZbus {
-    /// Fetch profile names
-    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(profiles) = Profile::get_profile_names() {
-            return Ok(profiles);
-        }
-        Err(Error::Failed(
-            "Failed to get all profile details".to_string(),
-        ))
-    }
-
-    /// Toggle to next platform_profile. Names provided by `Profiles`.
-    /// If fan-curves are supported will also activate a fan curve for profile.
-    fn next_profile(&mut self) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.set_next_profile()
-                .unwrap_or_else(|err| warn!("{}", err));
-            ctrl.save_config();
-        }
-        self.do_notification();
-    }
-
-    /// Fetch the active profile name
-    fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            return Ok(ctrl.config.active_profile);
-        }
-        Err(Error::Failed(
-            "Failed to get active profile name".to_string(),
-        ))
-    }
-
-    /// Set this platform_profile name as active
-    fn set_active_profile(&self, profile: Profile) {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            // Read first just incase the user has modified the config before calling this
-            ctrl.config.read();
-            Profile::set_profile(profile)
-                .map_err(|e| warn!("set_profile, {}", e))
-                .ok();
-            ctrl.config.active_profile = profile;
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-                .ok();
-
-            ctrl.save_config();
-        }
-        self.do_notification();
-    }
-
-    /// Get a list of profiles that have fan-curves enabled.
-    fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &ctrl.config.fan_curves {
-                return Ok(curves.get_enabled_curve_profiles().to_vec());
-            }
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-        }
-        Err(Error::Failed(
-            "Failed to get enabled fan curve names".to_string(),
-        ))
-    }
-
-    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
-    /// same profile mode
-    fn set_fan_curve_enabled(&mut self, profile: Profile, enabled: bool) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            return if let Some(curves) = &mut ctrl.config.fan_curves {
-                curves.set_profile_curve_enabled(profile, enabled);
-
-                ctrl.write_profile_curve_to_platform()
-                    .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-                    .ok();
-
-                ctrl.save_config();
-                Ok(())
-            } else {
-                Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
-            };
-        }
-        Err(Error::Failed(
-            "Failed to get enabled fan curve names".to_string(),
-        ))
-    }
-
-    /// Get the fan-curve data for the currently active Profile
-    fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &ctrl.config.fan_curves {
-                let curve = curves.get_fan_curves_for(profile);
-                return Ok(curve.clone());
-            }
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-        }
-        Err(Error::Failed("Failed to get fan curve data".to_string()))
-    }
-
-    /// Set the fan curve for the specified profile.
-    /// Will also activate the fan curve if the user is in the same mode.
-    fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &mut ctrl.config.fan_curves {
-                curves
-                    .save_fan_curve(curve, profile)
-                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            } else {
-                return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-            }
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("Profile::set_profile, {}", e))
-                .ok();
-            ctrl.save_config();
-        }
-        Ok(())
-    }
-
-    /// Reset the stored (self) and device curve to the defaults of the platform.
-    ///
-    /// Each platform_profile has a different default and the defualt can be read
-    /// only for the currently active profile.
-    fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            ctrl.set_active_curve_to_defaults()
-                .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
-                .ok();
-            ctrl.save_config();
-        }
-        Ok(())
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_profile(&self, profile: &Profile) -> zbus::Result<()> {}
-}
-
-impl ProfileZbus {
-    fn do_notification(&self) {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            self.notify_profile(&ctrl.config.active_profile)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-}
-
-impl crate::ZbusAdd for ProfileZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Profile"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("DbusFanAndCpu: add_to_server {}", err);
-                err
-            })
-            .ok();
-    }
-}

daemon/src/ctrl_rog_bios.rs

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

daemon/src/ctrl_supported.rs

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

daemon/src/daemon.rs

@@ -1,41 +1,36 @@
+use std::env;
 use std::error::Error;
 use std::io::Write;
 use std::sync::Arc;
-use std::sync::Mutex;
-use std::thread::sleep;
 use std::time::Duration;
-use std::{env, thread};
 
-use ::zbus::{fdo, Connection, ObjectServer};
+use ::zbus::export::futures_util::lock::Mutex;
+use ::zbus::Connection;
+use daemon::ctrl_anime::CtrlAnime;
 use log::LevelFilter;
 use log::{error, info, warn};
+use tokio::time::sleep;
+use zbus::SignalContext;
 
-use daemon::ctrl_anime::config::AnimeConfig;
-use daemon::ctrl_anime::zbus::CtrlAnimeZbus;
-use daemon::ctrl_anime::*;
-use daemon::ctrl_aura::config::AuraConfig;
-use daemon::ctrl_aura::controller::{
-    CtrlKbdLed, CtrlKbdLedReloader, CtrlKbdLedTask, CtrlKbdLedZbus,
+use daemon::ctrl_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::ctrl_charge::CtrlCharge;
-use daemon::ctrl_profiles::config::ProfileConfig;
-use daemon::ctrl_profiles::controller::CtrlProfileTask;
-use daemon::ctrl_rog_bios::CtrlRogBios;
-use daemon::error::RogError;
+use daemon::laptops::LaptopLedData;
 use daemon::{
     config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };
-use daemon::{
-    ctrl_profiles::{controller::CtrlPlatformProfile, zbus::ProfileZbus},
-    laptops::LaptopLedData,
-};
-use daemon::{CtrlTask, Reloadable, ZbusAdd};
+use daemon::{CtrlTask, Reloadable, ZbusRun};
 use rog_dbus::DBUS_NAME;
 use rog_profiles::Profile;
 
 static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 
-pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
     logger
         .target(env_logger::Target::Stdout)
@@ -62,105 +57,70 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     info!("     rog-aura v{}", rog_aura::VERSION);
     info!("     rog-dbus v{}", rog_dbus::VERSION);
     info!(" rog-profiles v{}", rog_profiles::VERSION);
-    info!("rog-supported v{}", rog_supported::VERSION);
+    info!("rog-platform v{}", rog_platform::VERSION);
 
-    start_daemon()?;
+    start_daemon().await?;
     Ok(())
 }
 
 /// The actual main loop for the daemon
-fn start_daemon() -> Result<(), Box<dyn Error>> {
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
     println!("{}", serde_json::to_string_pretty(&supported)?);
 
     // Start zbus server
-    let connection = Connection::new_system()?;
-    let fdo_connection = fdo::DBusProxy::new(&connection)?;
-    let mut object_server = ObjectServer::new(&connection);
+    let mut connection = Connection::system().await?;
 
     let config = Config::load();
     let config = Arc::new(Mutex::new(config));
 
-    supported.add_to_server(&mut object_server);
+    supported.add_to_server(&mut connection).await;
 
-    match CtrlRogBios::new(config.clone()) {
-        Ok(mut ctrl) => {
-            // 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);
+    match CtrlPlatform::new(config.clone()) {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("rog_bios_control: {}", err);
+            error!("CtrlPlatform: {}", err);
         }
     }
 
-    match CtrlCharge::new(config) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
+    match CtrlPower::new(config.clone()) {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPower::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("charge_control: {}", err);
+            error!("CtrlPower: {}", err);
         }
     }
 
     if Profile::is_platform_profile_supported() {
         let profile_config = ProfileConfig::load(PROFILE_CONFIG_PATH.into());
         match CtrlPlatformProfile::new(profile_config) {
-            Ok(mut ctrl) => {
-                ctrl.reload()
-                    .unwrap_or_else(|err| warn!("Profile control: {}", err));
-
-                let tmp = Arc::new(Mutex::new(ctrl));
-                ProfileZbus::new(tmp.clone()).add_to_server(&mut object_server);
-
-                let task = CtrlProfileTask::new(tmp);
-                thread::Builder::new().name("profile tasks".into()).spawn(
-                    move || -> Result<(), RogError> {
-                        loop {
-                            task.do_task()?;
-                            sleep(Duration::from_millis(100));
-                        }
-                    },
-                )?;
+            Ok(ctrl) => {
+                let zbus = ProfileZbus(Arc::new(Mutex::new(ctrl)));
+                let sig_ctx = ProfileZbus::signal_context(&connection)?;
+                start_tasks(zbus, &mut connection, sig_ctx).await?;
             }
             Err(err) => {
                 error!("Profile control: {}", err);
             }
         }
     } else {
-        warn!("platform_profile support not found. This requires kernel 5.15.x or the patch applied: https://lkml.org/lkml/2021/8/18/1022");
+        warn!("platform_profile support not found");
     }
 
     match CtrlAnime::new(AnimeConfig::load()) {
         Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlAnimeReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("AniMe: {}", err));
-
-            let zbus = CtrlAnimeZbus(inner.clone());
-            zbus.add_to_server(&mut object_server);
-
-            let task = CtrlAnimeTask::new(inner);
-            thread::Builder::new().name("anime tasks".into()).spawn(
-                move || -> Result<(), RogError> {
-                    loop {
-                        task.do_task()?;
-                    }
-                },
-            )?;
+            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("AniMe control: {}", err);
+            info!("AniMe control: {}", err);
         }
     }
 
@@ -168,23 +128,9 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
     let aura_config = AuraConfig::load(&laptop);
     match CtrlKbdLed::new(laptop, aura_config) {
         Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlKbdLedReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
-
-            CtrlKbdLedZbus::new(inner.clone()).add_to_server(&mut object_server);
-
-            let task = CtrlKbdLedTask::new(inner);
-            thread::Builder::new().name("keyboard tasks".into()).spawn(
-                move || -> Result<(), RogError> {
-                    loop {
-                        task.do_task()?;
-                    }
-                },
-            )?;
+            let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
             error!("Keyboard control: {}", err);
@@ -192,12 +138,29 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     // Request dbus name after finishing initalizing all functions
-    fdo_connection.request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
+    connection.request_name(DBUS_NAME).await?;
 
-    // Loop to check errors and iterate zbus server
     loop {
-        if let Err(err) = object_server.try_handle_next() {
-            error!("{}", err);
-        }
+        // This is just a blocker to idle and ensure the reator reacts
+        sleep(Duration::from_millis(1000)).await;
     }
 }
+
+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,3 +1,5 @@
+use rog_anime::error::AnimeError;
+use rog_platform::error::PlatformError;
 use rog_profiles::error::ProfileError;
 use std::convert::From;
 use std::fmt;
@@ -23,6 +25,14 @@ pub enum RogError {
     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 {
@@ -48,6 +58,22 @@ impl fmt::Display for RogError {
             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),
         }
     }
 }
@@ -60,6 +86,18 @@ impl From<ProfileError> for RogError {
     }
 }
 
+impl From<AnimeError> for RogError {
+    fn from(err: AnimeError) -> Self {
+        RogError::Anime(err)
+    }
+}
+
+impl From<PlatformError> for RogError {
+    fn from(err: PlatformError) -> Self {
+        RogError::Platform(err)
+    }
+}
+
 impl From<zbus::Error> for RogError {
     fn from(err: zbus::Error) -> Self {
         RogError::Zbus(err)

daemon/src/laptops.rs

@@ -1,10 +1,11 @@
 use log::{info, warn};
-use rog_aura::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() {
@@ -32,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,
 }
 
@@ -62,7 +64,7 @@ impl LaptopLedData {
             prod_family,
             board_names: vec![board_name],
             standard: vec![],
-            multizone: false,
+            multizone: vec![],
             per_key: false,
         }
     }
@@ -85,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(|_| {
-                        panic!("Could not deserialise {}", ASUS_LED_MODE_CONF)
-                    }));
+                    let mut tmp: LedSupportFile = toml::from_str(&buf)
+                        .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

@@ -5,52 +5,184 @@ pub mod config;
 pub mod ctrl_anime;
 /// Keyboard LED brightness control, RGB, and LED display modes
 pub mod ctrl_aura;
-/// Control of battery charge level
-pub mod ctrl_charge;
-/// Control CPU min/max freq and turbo, fan mode, fan curves
-///
-/// Intel machines can control:
-/// - CPU min/max frequency
-/// - CPU turbo enable/disable
-/// - Fan mode (normal, boost, silent)
-///
-/// AMD machines can control:
-/// - CPU turbo enable/disable
-/// - Fan mode (normal, boost, silent)
-/// - Fan min/max RPM curve
-pub mod ctrl_profiles;
 /// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
-pub mod ctrl_rog_bios;
+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;
 
 pub mod error;
 
 use crate::error::RogError;
-use config::Config;
-use zbus::ObjectServer;
+use async_trait::async_trait;
+use log::warn;
+use logind_zbus::manager::ManagerProxy;
+use zbus::{export::futures_util::StreamExt, Connection, SignalContext};
+use zvariant::ObjectPath;
 
-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();
+                                dbg!(&value);
+                                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 {
-    fn add_to_server(self, server: &mut ObjectServer);
+#[async_trait]
+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(&self) -> Result<(), RogError>;
-}
+    fn zbus_path() -> &'static str;
 
-pub trait CtrlTaskComplex {
-    type A;
+    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
+        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(
+        &self,
+        mut on_sleep: impl FnMut() + Send + 'static,
+        mut on_wake: impl FnMut() + Send + 'static,
+        mut on_shutdown: impl FnMut() + Send + 'static,
+        mut on_boot: impl FnMut() + Send + 'static,
+    ) {
+        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 {
+                            on_sleep();
+                        } else if !args.start() {
+                            on_wake();
+                        }
+                    }
+                }
+            }
+        });
+
+        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 {
+                            on_shutdown();
+                        } else if !args.start() {
+                            on_boot();
+                        }
+                    }
+                }
+            }
+        });
+    }
 }
 
 pub trait GetSupported {

daemon/src/systemd.rs

@@ -0,0 +1,90 @@
+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,
+}
+
+impl From<SystemdUnitState> for &str {
+    fn from(s: SystemdUnitState) -> Self {
+        match s {
+            SystemdUnitState::Active => "active",
+            SystemdUnitState::Inactive => "inactive",
+        }
+    }
+}
+
+/// 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)
+}
+
+/// 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/_asusctl

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

data/asus-notify.service

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

data/asusd-alt.service

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

data/asusd-ledmodes.toml

@@ -1,99 +1,149 @@
+[[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
-per_key = true
-
-[[led_data]]
-prod_family = "Zephyrus M"
-board_names = ["GM501GS"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LW"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 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"
-board_names = ["GM501GM", "GX531"]
+prod_family = "ROG Zephyrus M15"
+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", "G533QR", "G533QS", "G733QS", "G733QR", "G513QR", "G713QR"]
+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", "G513IH", "G513QY", "G713QM"]
+board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512", "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
+
+[[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
@@ -101,33 +151,47 @@ per_key = false
 prod_family = "ROG Zephyrus G15"
 board_names = ["GA503QE"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus G15"
-board_names = ["GA503Q"]
+board_names = ["GA503Q", "GA503R"]
 standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
-multizone = false
+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 = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Zephyrus Duo 15 SE"
 board_names = ["GX551Q"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Flow X13"
-board_names = ["GV301QH", "GV301QE"]
+board_names = ["GV301Q"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Strix"
+board_names = ["G513IC", "G513RC"]
+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|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|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"
+
+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}=="*Vivobook*", 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/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
-

design-patterns.md

@@ -18,70 +18,128 @@ Then for each trait that is required a new struct is required that can have the
 
 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>>);
 
-impl CtrlAnime {
-    <functions the controller exposes>
-}
+#[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 {
-    fn do_task(&self) -> Result<(), RogError> {
-       if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    // 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 {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    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) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlAnimeDisplay: add_to_server {}", err);
-                err
-            })
-            .ok();
+        // This is a provided free helper trait with pre-set body. It will move self in-to.
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
     }
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlAnimeZbus {
-    fn <zbus method>() {
-       if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    async fn <zbus method>() {
+       let lock = self.inner.lock().await;
+        <some action>
     }
 }
 ```

rog-anime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_anime"
-version = "1.3.0"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -9,22 +9,26 @@ 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"]
-dbus = ["zvariant", "zvariant_derive"]
+default = ["dbus", "detect"]
+dbus = ["zvariant", "zbus"]
+detect = ["sysfs-class"]
 
 [dependencies]
-png_pong = "^0.8.0"
-pix = "0.13"
-gif = "^0.11.2"
+png_pong.workspace = true
+pix.workspace = true
+gif.workspace = true
+log.workspace = true
 
-serde = "^1.0"
-serde_derive = "^1.0"
+serde.workspace = true
+serde_derive.workspace = true
 
-glam = { version = "0.14.0", features = ["serde"] }
+glam.workspace = true
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+zvariant = { workspace = true, optional = true }
+zbus = { workspace = true, optional = true }
+
+sysfs-class = { workspace = true, optional = true }

rog-anime/src/data.rs

@@ -1,17 +1,18 @@
 use std::{
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    convert::TryFrom,
     thread::sleep,
     time::{Duration, Instant},
 };
 
+use log::info;
 use serde_derive::{Deserialize, Serialize};
 #[cfg(feature = "dbus")]
-use zvariant_derive::Type;
+use zvariant::Type;
 
-use crate::{error::AnimeError, AnimTime, AnimeGif};
+use crate::{
+    error::{AnimeError, Result},
+    AnimTime, AnimeGif,
+};
 
 /// The first 7 bytes of a USB packet are accounted for by `USB_PREFIX1` and `USB_PREFIX2`
 const BLOCK_START: usize = 7;
@@ -19,48 +20,85 @@ const BLOCK_START: usize = 7;
 const BLOCK_END: usize = 634;
 /// Individual usable data length of each USB packet
 const PANE_LEN: usize = BLOCK_END - BLOCK_START;
-/// The length of usable data
-pub const ANIME_DATA_LEN: usize = PANE_LEN * 2;
 
+/// First packet is for GA401 + GA402
 const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
+/// Second packet is for GA401 + GA402
 const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
+/// Third packet is for GA402 matrix
+const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
-
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
 pub struct AnimePowerStates {
+    pub brightness: u8,
     pub enabled: bool,
     pub boot_anim_enabled: bool,
 }
 
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+pub enum AnimeType {
+    GA401,
+    GA402,
+}
+
+impl AnimeType {
+    /// The width of diagonal images
+    pub fn width(&self) -> usize {
+        match self {
+            AnimeType::GA401 => 74,
+            AnimeType::GA402 => 74,
+        }
+    }
+
+    /// The height of diagonal images
+    pub fn height(&self) -> usize {
+        match self {
+            AnimeType::GA401 => 36,
+            AnimeType::GA402 => 39,
+        }
+    }
+
+    /// The length of usable data for this type
+    pub fn data_length(&self) -> usize {
+        match self {
+            AnimeType::GA401 => PANE_LEN * 2,
+            AnimeType::GA402 => PANE_LEN * 3,
+        }
+    }
+}
+
 /// The minimal serializable data that can be transferred over wire types.
 /// Other data structures in `rog_anime` will convert to this.
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AnimeDataBuffer(Vec<u8>);
-
-impl Default for AnimeDataBuffer {
-    fn default() -> Self {
-        Self::new()
-    }
+pub struct AnimeDataBuffer {
+    data: Vec<u8>,
+    anime: AnimeType,
 }
 
 impl AnimeDataBuffer {
     #[inline]
-    pub fn new() -> Self {
-        AnimeDataBuffer(vec![0u8; ANIME_DATA_LEN])
+    pub fn new(anime: AnimeType) -> Self {
+        let len = anime.data_length();
+
+        AnimeDataBuffer {
+            data: vec![0u8; len],
+            anime,
+        }
     }
 
     /// Get the inner data buffer
     #[inline]
-    pub fn get(&self) -> &[u8] {
-        &self.0
+    pub fn data(&self) -> &[u8] {
+        &self.data
     }
 
     /// Get a mutable slice of the inner buffer
     #[inline]
-    pub fn get_mut(&mut self) -> &mut [u8] {
-        &mut self.0
+    pub fn data_mut(&mut self) -> &mut [u8] {
+        &mut self.data
     }
 
     /// Create from a vector of bytes
@@ -68,35 +106,51 @@ impl AnimeDataBuffer {
     /// # Panics
     /// Will panic if the vector length is not `ANIME_DATA_LEN`
     #[inline]
-    pub fn from_vec(input: Vec<u8>) -> Self {
-        assert_eq!(input.len(), ANIME_DATA_LEN);
-        Self(input)
+    pub fn from_vec(anime: AnimeType, data: Vec<u8>) -> Result<Self> {
+        if data.len() != anime.data_length() {
+            return Err(AnimeError::DataBufferLength);
+        }
+
+        Ok(Self { data, anime })
     }
 }
 
 /// The two packets to be written to USB
-pub type AnimePacketType = [[u8; 640]; 2];
+pub type AnimePacketType = Vec<[u8; 640]>;
 
-impl From<AnimeDataBuffer> for AnimePacketType {
-    #[inline]
-    fn from(anime: AnimeDataBuffer) -> Self {
-        assert!(anime.0.len() == ANIME_DATA_LEN);
-        let mut buffers = [[0; 640]; 2];
-        for (idx, chunk) in anime.0.as_slice().chunks(PANE_LEN).enumerate() {
+impl TryFrom<AnimeDataBuffer> for AnimePacketType {
+    type Error = AnimeError;
+
+    fn try_from(anime: AnimeDataBuffer) -> std::result::Result<Self, Self::Error> {
+        if anime.data.len() != anime.anime.data_length() {
+            return Err(AnimeError::DataBufferLength);
+        }
+
+        let mut buffers = match anime.anime {
+            AnimeType::GA401 => vec![[0; 640]; 2],
+            AnimeType::GA402 => vec![[0; 640]; 3],
+        };
+
+        for (idx, chunk) in anime.data.as_slice().chunks(PANE_LEN).enumerate() {
             buffers[idx][BLOCK_START..BLOCK_END].copy_from_slice(chunk);
         }
         buffers[0][..7].copy_from_slice(&USB_PREFIX1);
         buffers[1][..7].copy_from_slice(&USB_PREFIX2);
-        buffers
+
+        if matches!(anime.anime, AnimeType::GA402) {
+            buffers[2][..7].copy_from_slice(&USB_PREFIX3);
+        }
+        Ok(buffers)
     }
 }
 
 /// This runs the animations as a blocking loop by using the `callback` to write data
+///
+/// If `callback` is `Ok(true)` then `run_animation` will exit the animation loop early.
 pub fn run_animation(
     frames: &AnimeGif,
-    do_early_return: Arc<AtomicBool>,
-    callback: &dyn Fn(AnimeDataBuffer) -> Result<(), AnimeError>,
-) -> Result<(), AnimeError> {
+    callback: &dyn Fn(AnimeDataBuffer) -> Result<bool>,
+) -> Result<()> {
     let mut count = 0;
     let start = Instant::now();
 
@@ -140,14 +194,11 @@ pub fn run_animation(
     'animation: loop {
         for frame in frames.frames() {
             let frame_start = Instant::now();
-            if do_early_return.load(Ordering::SeqCst) {
-                return Ok(());
-            }
             let mut output = frame.frame().clone();
 
             if let AnimTime::Fade(_) = frames.duration() {
                 if frame_start <= start + fade_in {
-                    for pixel in output.get_mut() {
+                    for pixel in output.data_mut() {
                         *pixel = (*pixel as f32 * fade_in_accum) as u8;
                     }
                     fade_in_accum = fade_in_step * (frame_start - start).as_secs_f32();
@@ -158,18 +209,20 @@ pub fn run_animation(
                     } else {
                         fade_out_accum = 0.0;
                     }
-                    for pixel in output.get_mut() {
+                    for pixel in output.data_mut() {
                         *pixel = (*pixel as f32 * fade_out_accum) as u8;
                     }
                 }
             }
 
-            callback(output)?;
+            if matches!(callback(output), Ok(true)) {
+                info!("rog-anime: frame-loop callback asked to exit early");
+                return Ok(());
+            }
 
             if timed && Instant::now().duration_since(start) > run_time {
                 break 'animation;
             }
-
             sleep(frame.delay());
         }
         if let AnimTime::Count(times) = frames.duration() {

rog-anime/src/diagonal.rs

@@ -1,40 +1,36 @@
 use std::{path::Path, time::Duration};
 
 use crate::{
-    data::{AnimeDataBuffer, ANIME_DATA_LEN},
-    error::AnimeError,
+    data::AnimeDataBuffer,
+    error::{AnimeError, Result},
+    AnimeType,
 };
 
-const WIDTH: usize = 74;
-const HEIGHT: usize = 36;
-
 /// Mostly intended to be used with ASUS gifs, but can be used for other purposes (like images)
 #[derive(Debug, Clone)]
-pub struct AnimeDiagonal([[u8; WIDTH]; HEIGHT], Option<Duration>);
-
-impl Default for AnimeDiagonal {
-    #[inline]
-    fn default() -> Self {
-        Self::new(None)
-    }
-}
+pub struct AnimeDiagonal(AnimeType, Vec<Vec<u8>>, Option<Duration>);
 
 impl AnimeDiagonal {
     #[inline]
-    pub fn new(duration: Option<Duration>) -> Self {
-        Self([[0u8; WIDTH]; HEIGHT], duration)
+    pub fn new(anime_type: AnimeType, duration: Option<Duration>) -> Self {
+        Self(
+            anime_type,
+            vec![vec![0; anime_type.width()]; anime_type.height()],
+            duration,
+        )
     }
 
     #[inline]
-    pub fn get_mut(&mut self) -> &mut [[u8; WIDTH]; HEIGHT] {
-        &mut self.0
+    pub fn get_mut(&mut self) -> &mut Vec<Vec<u8>> {
+        &mut self.1
     }
 
     /// Get a full diagonal row where `x` `y` is the starting point  and `len` is the length of data.
     fn get_row(&self, x: usize, y: usize, len: usize) -> Vec<u8> {
         let mut buf = Vec::with_capacity(len);
         for i in 0..len {
-            let val = self.0[HEIGHT - y - i - 1][x + i];
+            let y = self.0.height() - y - i - 1;
+            let val = self.1[y][x + i];
             buf.push(val);
         }
         buf
@@ -47,13 +43,14 @@ impl AnimeDiagonal {
         path: &Path,
         duration: Option<Duration>,
         bright: f32,
-    ) -> Result<Self, AnimeError> {
+        anime_type: AnimeType,
+    ) -> Result<Self> {
         let data = std::fs::read(path)?;
         let data = std::io::Cursor::new(data);
         let decoder = png_pong::Decoder::new(data)?.into_steps();
         let png_pong::Step { raster, delay: _ } = decoder.last().ok_or(AnimeError::NoFrames)??;
 
-        let mut matrix = AnimeDiagonal::new(duration);
+        let mut matrix = AnimeDiagonal::new(anime_type, duration);
 
         match raster {
             png_pong::PngRaster::Gray8(ras) => {
@@ -100,7 +97,9 @@ impl AnimeDiagonal {
                         + (<u8>::from(px.two()) / 3) as f32
                         + (<u8>::from(px.three()) / 3) as f32
                 };
-                matrix.0[y][x] = (v * bright) as u8;
+                if y < matrix.1.len() && x < matrix.1[y].len() {
+                    matrix.1[y][x] = (v * bright) as u8;
+                }
             }
         }
     }
@@ -123,75 +122,547 @@ impl AnimeDiagonal {
                         + ((<u16>::from(px.two()) / 3) >> 8) as f32
                         + ((<u16>::from(px.three()) / 3) >> 8) as f32
                 };
-                matrix.0[y][x] = (v * bright) as u8;
+                matrix.1[y][x] = (v * bright) as u8;
             }
         }
     }
-}
 
-impl From<&AnimeDiagonal> for AnimeDataBuffer {
+    /// Convert to a data buffer that can be sent over dbus
+    #[inline]
+    pub fn into_data_buffer(&self, anime_type: AnimeType) -> Result<AnimeDataBuffer> {
+        match anime_type {
+            AnimeType::GA401 => self.to_ga401_packets(),
+            AnimeType::GA402 => self.to_ga402_packets(),
+        }
+    }
+
     /// Do conversion from the nested Vec in AnimeMatrix to the two required
     /// packets suitable for sending over USB
-    #[inline]
-    fn from(anime: &AnimeDiagonal) -> Self {
-        let mut buf = vec![0u8; ANIME_DATA_LEN];
+    fn to_ga401_packets(&self) -> Result<AnimeDataBuffer> {
+        let mut buf = vec![0u8; AnimeType::GA401.data_length()];
 
-        buf[1..=32].copy_from_slice(&anime.get_row(0, 3, 32));
-        buf[34..=66].copy_from_slice(&anime.get_row(0, 2, 33));
-        buf[69..=101].copy_from_slice(&anime.get_row(1, 2, 33)); // ?!
-        buf[102..=134].copy_from_slice(&anime.get_row(1, 1, 33));
-        buf[137..=169].copy_from_slice(&anime.get_row(2, 1, 33));
-        buf[170..=202].copy_from_slice(&anime.get_row(2, 0, 33));
-        buf[204..=236].copy_from_slice(&anime.get_row(3, 0, 33));
-        buf[237..=268].copy_from_slice(&anime.get_row(4, 0, 32));
-        buf[270..=301].copy_from_slice(&anime.get_row(5, 0, 32));
-        buf[302..=332].copy_from_slice(&anime.get_row(6, 0, 31));
-        buf[334..=364].copy_from_slice(&anime.get_row(7, 0, 31));
-        buf[365..=394].copy_from_slice(&anime.get_row(8, 0, 30));
-        buf[396..=425].copy_from_slice(&anime.get_row(9, 0, 30));
-        buf[426..=454].copy_from_slice(&anime.get_row(10, 0, 29));
-        buf[456..=484].copy_from_slice(&anime.get_row(11, 0, 29));
-        buf[485..=512].copy_from_slice(&anime.get_row(12, 0, 28));
-        buf[514..=541].copy_from_slice(&anime.get_row(13, 0, 28));
-        buf[542..=568].copy_from_slice(&anime.get_row(14, 0, 27));
-        buf[570..=596].copy_from_slice(&anime.get_row(15, 0, 27));
-        buf[597..=622].copy_from_slice(&anime.get_row(16, 0, 26));
-        buf[624..=649].copy_from_slice(&anime.get_row(17, 0, 26));
-        buf[650..=674].copy_from_slice(&anime.get_row(18, 0, 25));
-        buf[676..=700].copy_from_slice(&anime.get_row(19, 0, 25));
-        buf[701..=724].copy_from_slice(&anime.get_row(20, 0, 24));
-        buf[726..=749].copy_from_slice(&anime.get_row(21, 0, 24));
-        buf[750..=772].copy_from_slice(&anime.get_row(22, 0, 23));
-        buf[774..=796].copy_from_slice(&anime.get_row(23, 0, 23));
-        buf[797..=818].copy_from_slice(&anime.get_row(24, 0, 22));
-        buf[820..=841].copy_from_slice(&anime.get_row(25, 0, 22));
-        buf[842..=862].copy_from_slice(&anime.get_row(26, 0, 21));
-        buf[864..=884].copy_from_slice(&anime.get_row(27, 0, 21));
-        buf[885..=904].copy_from_slice(&anime.get_row(28, 0, 20));
-        buf[906..=925].copy_from_slice(&anime.get_row(29, 0, 20));
-        buf[926..=944].copy_from_slice(&anime.get_row(30, 0, 19));
-        buf[946..=964].copy_from_slice(&anime.get_row(31, 0, 19));
-        buf[965..=982].copy_from_slice(&anime.get_row(32, 0, 18));
-        buf[984..=1001].copy_from_slice(&anime.get_row(33, 0, 18));
-        buf[1002..=1018].copy_from_slice(&anime.get_row(34, 0, 17));
-        buf[1020..=1036].copy_from_slice(&anime.get_row(35, 0, 17));
-        buf[1037..=1052].copy_from_slice(&anime.get_row(36, 0, 16));
-        buf[1054..=1069].copy_from_slice(&anime.get_row(37, 0, 16));
-        buf[1070..=1084].copy_from_slice(&anime.get_row(38, 0, 15));
-        buf[1086..=1100].copy_from_slice(&anime.get_row(39, 0, 15));
-        buf[1101..=1114].copy_from_slice(&anime.get_row(40, 0, 14));
-        buf[1116..=1129].copy_from_slice(&anime.get_row(41, 0, 14));
-        buf[1130..=1142].copy_from_slice(&anime.get_row(42, 0, 13));
-        buf[1144..=1156].copy_from_slice(&anime.get_row(43, 0, 13));
-        buf[1157..=1168].copy_from_slice(&anime.get_row(44, 0, 12));
-        buf[1170..=1181].copy_from_slice(&anime.get_row(45, 0, 12));
-        buf[1182..=1192].copy_from_slice(&anime.get_row(46, 0, 11));
-        buf[1194..=1204].copy_from_slice(&anime.get_row(47, 0, 11));
-        buf[1205..=1214].copy_from_slice(&anime.get_row(48, 0, 10));
-        buf[1216..=1225].copy_from_slice(&anime.get_row(49, 0, 10));
-        buf[1226..=1234].copy_from_slice(&anime.get_row(50, 0, 9));
-        buf[1236..=1244].copy_from_slice(&anime.get_row(51, 0, 9));
+        buf[1..=32].copy_from_slice(&self.get_row(0, 3, 32));
+        buf[34..=66].copy_from_slice(&self.get_row(0, 2, 33));
+        buf[69..=101].copy_from_slice(&self.get_row(1, 2, 33)); // ?!
+        buf[102..=134].copy_from_slice(&self.get_row(1, 1, 33));
+        buf[137..=169].copy_from_slice(&self.get_row(2, 1, 33));
+        buf[170..=202].copy_from_slice(&self.get_row(2, 0, 33));
+        buf[204..=236].copy_from_slice(&self.get_row(3, 0, 33)); // This and above cause overflow?
+        buf[237..=268].copy_from_slice(&self.get_row(4, 0, 32));
+        buf[270..=301].copy_from_slice(&self.get_row(5, 0, 32));
+        buf[302..=332].copy_from_slice(&self.get_row(6, 0, 31));
+        buf[334..=364].copy_from_slice(&self.get_row(7, 0, 31));
+        buf[365..=394].copy_from_slice(&self.get_row(8, 0, 30));
+        buf[396..=425].copy_from_slice(&self.get_row(9, 0, 30));
+        buf[426..=454].copy_from_slice(&self.get_row(10, 0, 29));
+        buf[456..=484].copy_from_slice(&self.get_row(11, 0, 29));
+        buf[485..=512].copy_from_slice(&self.get_row(12, 0, 28));
+        buf[514..=541].copy_from_slice(&self.get_row(13, 0, 28));
+        buf[542..=568].copy_from_slice(&self.get_row(14, 0, 27));
+        buf[570..=596].copy_from_slice(&self.get_row(15, 0, 27));
+        buf[597..=622].copy_from_slice(&self.get_row(16, 0, 26));
+        buf[624..=649].copy_from_slice(&self.get_row(17, 0, 26));
+        buf[650..=674].copy_from_slice(&self.get_row(18, 0, 25));
+        buf[676..=700].copy_from_slice(&self.get_row(19, 0, 25));
+        buf[701..=724].copy_from_slice(&self.get_row(20, 0, 24));
+        buf[726..=749].copy_from_slice(&self.get_row(21, 0, 24));
+        buf[750..=772].copy_from_slice(&self.get_row(22, 0, 23));
+        buf[774..=796].copy_from_slice(&self.get_row(23, 0, 23));
+        buf[797..=818].copy_from_slice(&self.get_row(24, 0, 22));
+        buf[820..=841].copy_from_slice(&self.get_row(25, 0, 22));
+        buf[842..=862].copy_from_slice(&self.get_row(26, 0, 21));
+        buf[864..=884].copy_from_slice(&self.get_row(27, 0, 21));
+        buf[885..=904].copy_from_slice(&self.get_row(28, 0, 20));
+        buf[906..=925].copy_from_slice(&self.get_row(29, 0, 20));
+        buf[926..=944].copy_from_slice(&self.get_row(30, 0, 19));
+        buf[946..=964].copy_from_slice(&self.get_row(31, 0, 19));
+        buf[965..=982].copy_from_slice(&self.get_row(32, 0, 18));
+        buf[984..=1001].copy_from_slice(&self.get_row(33, 0, 18));
+        buf[1002..=1018].copy_from_slice(&self.get_row(34, 0, 17));
+        buf[1020..=1036].copy_from_slice(&self.get_row(35, 0, 17));
+        buf[1037..=1052].copy_from_slice(&self.get_row(36, 0, 16));
+        buf[1054..=1069].copy_from_slice(&self.get_row(37, 0, 16));
+        buf[1070..=1084].copy_from_slice(&self.get_row(38, 0, 15));
+        buf[1086..=1100].copy_from_slice(&self.get_row(39, 0, 15));
+        buf[1101..=1114].copy_from_slice(&self.get_row(40, 0, 14));
+        buf[1116..=1129].copy_from_slice(&self.get_row(41, 0, 14));
+        buf[1130..=1142].copy_from_slice(&self.get_row(42, 0, 13));
+        buf[1144..=1156].copy_from_slice(&self.get_row(43, 0, 13));
+        buf[1157..=1168].copy_from_slice(&self.get_row(44, 0, 12));
+        buf[1170..=1181].copy_from_slice(&self.get_row(45, 0, 12));
+        buf[1182..=1192].copy_from_slice(&self.get_row(46, 0, 11));
+        buf[1194..=1204].copy_from_slice(&self.get_row(47, 0, 11));
+        buf[1205..=1214].copy_from_slice(&self.get_row(48, 0, 10));
+        buf[1216..=1225].copy_from_slice(&self.get_row(49, 0, 10));
+        buf[1226..=1234].copy_from_slice(&self.get_row(50, 0, 9));
+        buf[1236..=1244].copy_from_slice(&self.get_row(51, 0, 9));
 
-        AnimeDataBuffer::from_vec(buf)
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA401, buf)
+    }
+
+    fn to_ga402_packets(&self) -> Result<AnimeDataBuffer> {
+        let mut buf = vec![0u8; AnimeType::GA402.data_length()];
+        let mut start_index: usize = 0;
+
+        fn copy_slice(
+            buf: &mut [u8],
+            anime: &AnimeDiagonal,
+            x: usize,
+            y: usize,
+            start_index: &mut usize,
+            len: usize,
+        ) {
+            buf[*start_index..*start_index + len].copy_from_slice(&anime.get_row(x, y, len));
+            *start_index += len;
+        }
+
+        let b = &mut buf;
+        let a = &self;
+        copy_slice(b, a, 0, 5, &mut start_index, 34);
+        copy_slice(b, a, 1, 5, &mut start_index, 34);
+        copy_slice(b, a, 1, 4, &mut start_index, 34);
+        copy_slice(b, a, 2, 4, &mut start_index, 34);
+        copy_slice(b, a, 2, 3, &mut start_index, 34);
+        copy_slice(b, a, 3, 3, &mut start_index, 34);
+        copy_slice(b, a, 3, 2, &mut start_index, 34);
+        copy_slice(b, a, 4, 2, &mut start_index, 34);
+        copy_slice(b, a, 4, 1, &mut start_index, 34);
+        copy_slice(b, a, 5, 1, &mut start_index, 34);
+        copy_slice(b, a, 5, 0, &mut start_index, 34);
+        copy_slice(b, a, 6, 0, &mut start_index, 34);
+        copy_slice(b, a, 7, 0, &mut start_index, 33);
+        copy_slice(b, a, 8, 0, &mut start_index, 33);
+        copy_slice(b, a, 9, 0, &mut start_index, 32);
+        copy_slice(b, a, 10, 0, &mut start_index, 32);
+        copy_slice(b, a, 11, 0, &mut start_index, 31);
+        copy_slice(b, a, 12, 0, &mut start_index, 31);
+        copy_slice(b, a, 13, 0, &mut start_index, 30);
+        copy_slice(b, a, 14, 0, &mut start_index, 30);
+        copy_slice(b, a, 15, 0, &mut start_index, 29);
+        copy_slice(b, a, 16, 0, &mut start_index, 29);
+        copy_slice(b, a, 17, 0, &mut start_index, 28);
+        copy_slice(b, a, 18, 0, &mut start_index, 28);
+        copy_slice(b, a, 19, 0, &mut start_index, 27);
+        copy_slice(b, a, 20, 0, &mut start_index, 27);
+        copy_slice(b, a, 21, 0, &mut start_index, 26);
+        copy_slice(b, a, 22, 0, &mut start_index, 26);
+        copy_slice(b, a, 23, 0, &mut start_index, 25);
+        copy_slice(b, a, 24, 0, &mut start_index, 25);
+        copy_slice(b, a, 25, 0, &mut start_index, 24);
+        copy_slice(b, a, 26, 0, &mut start_index, 24);
+        copy_slice(b, a, 27, 0, &mut start_index, 23);
+        copy_slice(b, a, 28, 0, &mut start_index, 23);
+        copy_slice(b, a, 29, 0, &mut start_index, 22);
+        copy_slice(b, a, 30, 0, &mut start_index, 22);
+        copy_slice(b, a, 31, 0, &mut start_index, 21);
+        copy_slice(b, a, 32, 0, &mut start_index, 21);
+        copy_slice(b, a, 33, 0, &mut start_index, 20);
+        copy_slice(b, a, 34, 0, &mut start_index, 20);
+        copy_slice(b, a, 35, 0, &mut start_index, 19);
+        copy_slice(b, a, 36, 0, &mut start_index, 19);
+        copy_slice(b, a, 37, 0, &mut start_index, 18);
+        copy_slice(b, a, 38, 0, &mut start_index, 18);
+        copy_slice(b, a, 39, 0, &mut start_index, 17);
+        copy_slice(b, a, 40, 0, &mut start_index, 17);
+        copy_slice(b, a, 41, 0, &mut start_index, 16);
+        copy_slice(b, a, 42, 0, &mut start_index, 16);
+        copy_slice(b, a, 43, 0, &mut start_index, 15);
+        copy_slice(b, a, 44, 0, &mut start_index, 15);
+        copy_slice(b, a, 45, 0, &mut start_index, 14);
+        copy_slice(b, a, 46, 0, &mut start_index, 14);
+        copy_slice(b, a, 47, 0, &mut start_index, 13);
+        copy_slice(b, a, 48, 0, &mut start_index, 13);
+        copy_slice(b, a, 49, 0, &mut start_index, 12);
+        copy_slice(b, a, 50, 0, &mut start_index, 12);
+        copy_slice(b, a, 51, 0, &mut start_index, 11);
+        copy_slice(b, a, 52, 0, &mut start_index, 11);
+        copy_slice(b, a, 53, 0, &mut start_index, 10);
+        copy_slice(b, a, 54, 0, &mut start_index, 10);
+        copy_slice(b, a, 55, 0, &mut start_index, 9);
+
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{convert::TryFrom, path::PathBuf};
+
+    use crate::{AnimeDiagonal, AnimePacketType, AnimeType};
+
+    #[test]
+    fn ga401_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga401-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA401).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA401).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+
+    #[test]
+    fn ga402_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga402-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
+    }
+
+    #[test]
+    #[ignore = "Needs the packets verified with capture"]
+    fn ga402_diagonal_fullbright_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x68, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x67, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga402-diagonal-fullbright.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
     }
 }

rog-anime/src/error.rs

@@ -3,6 +3,8 @@ use png_pong::decode::Error as PngError;
 use std::error::Error;
 use std::fmt;
 
+pub type Result<T> = std::result::Result<T, AnimeError>;
+
 #[derive(Debug)]
 pub enum AnimeError {
     NoFrames,
@@ -13,6 +15,13 @@ pub enum AnimeError {
     /// The input was incorrect size, expected size is `IncorrectSize(width, height)`
     IncorrectSize(u32, u32),
     Dbus(String),
+    Udev(String, std::io::Error),
+    NoDevice,
+    UnsupportedDevice,
+    InvalidBrightness(f32),
+    DataBufferLength,
+    PixelGifWidth(usize),
+    PixelGifHeight(usize),
 }
 
 impl fmt::Display for AnimeError {
@@ -30,6 +39,25 @@ impl fmt::Display for AnimeError {
                 width, height
             ),
             AnimeError::Dbus(detail) => write!(f, "{}", detail),
+            AnimeError::Udev(deets, error) => write!(f, "udev {}: {}", deets, error),
+            AnimeError::NoDevice => write!(f, "No AniMe Matrix device found"),
+            AnimeError::DataBufferLength => write!(
+                f,
+                "The data buffer was incorrect length for generating USB packets"
+            ),
+            AnimeError::UnsupportedDevice => write!(f, "Unsupported AniMe Matrix device found"),
+            AnimeError::InvalidBrightness(bright) => write!(
+                f,
+                "Image brightness must be between 0.0 and 1.0 (inclusive), was {}",
+                bright
+            ),
+            AnimeError::PixelGifWidth(n) => {
+                write!(f, "The gif used for pixel-perfect gif is is wider than {n}")
+            }
+            AnimeError::PixelGifHeight(n) => write!(
+                f,
+                "The gif used for pixel-perfect gif is is taller than {n}"
+            ),
         }
     }
 }
@@ -56,3 +84,10 @@ impl From<DecodingError> for AnimeError {
         AnimeError::Gif(err)
     }
 }
+
+impl From<AnimeError> for zbus::fdo::Error {
+    #[inline]
+    fn from(err: AnimeError) -> Self {
+        zbus::fdo::Error::Failed(format!("{}", err))
+    }
+}

rog-anime/src/gif.rs

@@ -1,8 +1,10 @@
 use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
+use std::convert::TryFrom;
 use std::{fs::File, path::Path, time::Duration};
 
-use crate::{error::AnimeError, AnimeDataBuffer, AnimeDiagonal, AnimeImage, Pixel};
+use crate::error::AnimeError;
+use crate::{error::Result, AnimeDataBuffer, AnimeDiagonal, AnimeImage, AnimeType, Pixel};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AnimeFrame {
@@ -92,8 +94,9 @@ impl AnimeGif {
         file_name: &Path,
         duration: AnimTime,
         brightness: f32,
-    ) -> Result<Self, AnimeError> {
-        let mut matrix = AnimeDiagonal::new(None);
+        anime_type: AnimeType,
+    ) -> Result<Self> {
+        let mut matrix = AnimeDiagonal::new(anime_type, None);
 
         let mut decoder = gif::DecodeOptions::new();
         // Configure the decoder such that it will expand the image to RGBA.
@@ -115,13 +118,22 @@ impl AnimeGif {
                         // should be t but not in some gifs? What, ASUS, what?
                         continue;
                     }
-                    matrix.get_mut()[y + frame.top as usize][x + frame.left as usize] =
-                        (px[0] as f32 * brightness) as u8;
+                    let tmp = matrix.get_mut();
+                    let y = y + frame.top as usize;
+                    if y >= tmp.len() {
+                        return Err(AnimeError::PixelGifHeight(tmp.len()));
+                    }
+                    let x = x + frame.left as usize;
+                    if x >= tmp[y].len() {
+                        return Err(AnimeError::PixelGifWidth(tmp[y].len()));
+                    }
+
+                    matrix.get_mut()[y][x] = (px[0] as f32 * brightness) as u8;
                 }
             }
 
             frames.push(AnimeFrame {
-                data: <AnimeDataBuffer>::from(&matrix),
+                data: matrix.into_data_buffer(anime_type)?,
                 delay: Duration::from_millis(wait as u64),
             });
         }
@@ -132,10 +144,11 @@ impl AnimeGif {
     #[inline]
     pub fn from_diagonal_png(
         file_name: &Path,
+        anime_type: AnimeType,
         duration: AnimTime,
         brightness: f32,
-    ) -> Result<Self, AnimeError> {
-        let image = AnimeDiagonal::from_png(file_name, None, brightness)?;
+    ) -> Result<Self> {
+        let image = AnimeDiagonal::from_png(file_name, None, brightness, anime_type)?;
 
         let mut total = Duration::from_millis(1000);
         if let AnimTime::Fade(fade) = duration {
@@ -148,7 +161,7 @@ impl AnimeGif {
         let frame_count = total.as_millis() / 30;
 
         let single = AnimeFrame {
-            data: <AnimeDataBuffer>::from(&image),
+            data: image.into_data_buffer(anime_type)?,
             delay: Duration::from_millis(30),
         };
         let frames = vec![single; frame_count as usize];
@@ -166,7 +179,8 @@ impl AnimeGif {
         translation: Vec2,
         duration: AnimTime,
         brightness: f32,
-    ) -> Result<Self, AnimeError> {
+        anime_type: AnimeType,
+    ) -> Result<Self> {
         let mut frames = Vec::new();
 
         let mut decoder = gif::DecodeOptions::new();
@@ -187,7 +201,8 @@ impl AnimeGif {
             brightness,
             pixels,
             decoder.width() as u32,
-        );
+            anime_type,
+        )?;
 
         while let Some(frame) = decoder.read_next_frame()? {
             let wait = frame.delay * 10;
@@ -201,7 +216,8 @@ impl AnimeGif {
                     brightness,
                     pixels,
                     width as u32,
-                );
+                    anime_type,
+                )?;
             }
             for (y, row) in frame.buffer.chunks(frame.width as usize * 4).enumerate() {
                 for (x, px) in row.chunks(4).enumerate() {
@@ -220,7 +236,7 @@ impl AnimeGif {
             image.update();
 
             frames.push(AnimeFrame {
-                data: <AnimeDataBuffer>::from(&image),
+                data: <AnimeDataBuffer>::try_from(&image)?,
                 delay: Duration::from_millis(wait as u64),
             });
         }
@@ -238,8 +254,10 @@ impl AnimeGif {
         translation: Vec2,
         duration: AnimTime,
         brightness: f32,
-    ) -> Result<Self, AnimeError> {
-        let image = AnimeImage::from_png(file_name, scale, angle, translation, brightness)?;
+        anime_type: AnimeType,
+    ) -> Result<Self> {
+        let image =
+            AnimeImage::from_png(file_name, scale, angle, translation, brightness, anime_type)?;
 
         let mut total = Duration::from_millis(1000);
         if let AnimTime::Fade(fade) = duration {
@@ -252,7 +270,7 @@ impl AnimeGif {
         let frame_count = total.as_millis() / 30;
 
         let single = AnimeFrame {
-            data: <AnimeDataBuffer>::from(&image),
+            data: <AnimeDataBuffer>::try_from(&image)?,
             delay: Duration::from_millis(30),
         };
         let frames = vec![single; frame_count as usize];

rog-anime/src/grid.rs

@@ -1,8 +1,10 @@
-use std::time::Duration;
+use std::convert::TryFrom;
 
-use crate::data::{AnimeDataBuffer, ANIME_DATA_LEN};
-use crate::image::LED_IMAGE_POSITIONS;
+use crate::data::AnimeDataBuffer;
+use crate::error::{AnimeError, Result};
+use crate::{AnimeImage, AnimeType};
 
+// TODO: Adjust these sizes as WIDTH_GA401 WIDTH_GA402
 const WIDTH: usize = 33;
 const HEIGHT: usize = 55;
 
@@ -14,41 +16,40 @@ const HEIGHT: usize = 55;
 ///
 /// **Note:** the columns in each odd row are offset by half a pixel left
 #[derive(Debug, Clone)]
-pub struct AnimeGrid([[u8; WIDTH]; HEIGHT], Option<Duration>);
-
-impl Default for AnimeGrid {
-    #[inline]
-    fn default() -> Self {
-        Self::new(None)
-    }
+pub struct AnimeGrid {
+    anime_type: AnimeType,
+    data: [[u8; WIDTH]; HEIGHT],
 }
 
 impl AnimeGrid {
     #[inline]
-    pub fn new(duration: Option<Duration>) -> Self {
-        AnimeGrid([[0u8; WIDTH]; HEIGHT], duration)
+    pub fn new(anime_type: AnimeType) -> Self {
+        Self {
+            anime_type,
+            data: [[0u8; WIDTH]; HEIGHT],
+        }
     }
 
     /// Set a position in the grid with a brightness value
     #[inline]
     pub fn set(&mut self, x: usize, y: usize, b: u8) {
-        self.0[y][x] = b;
+        self.data[y][x] = b;
     }
 
     #[inline]
     pub fn get(&self) -> &[[u8; WIDTH]; HEIGHT] {
-        &self.0
+        &self.data
     }
 
     #[inline]
     pub fn get_mut(&mut self) -> &mut [[u8; WIDTH]; HEIGHT] {
-        &mut self.0
+        &mut self.data
     }
 
     /// Fill the grid with a value
     #[inline]
     pub fn fill_with(&mut self, fill: u8) {
-        for row in self.0.iter_mut() {
+        for row in self.data.iter_mut() {
             for x in row.iter_mut() {
                 *x = fill;
             }
@@ -89,21 +90,25 @@ impl AnimeGrid {
     // }
 }
 
-impl From<AnimeGrid> for AnimeDataBuffer {
+impl TryFrom<AnimeGrid> for AnimeDataBuffer {
+    type Error = AnimeError;
+
     /// Do conversion from the nested Vec in AniMeMatrix to the two required
     /// packets suitable for sending over USB
-    #[inline]
-    fn from(anime: AnimeGrid) -> Self {
-        let mut buf = vec![0u8; ANIME_DATA_LEN];
+    fn try_from(anime: AnimeGrid) -> Result<Self> {
+        let mut buf = vec![0u8; anime.anime_type.data_length()];
 
-        for (idx, pos) in LED_IMAGE_POSITIONS.iter().enumerate() {
+        for (idx, pos) in AnimeImage::generate_image_positioning(anime.anime_type)
+            .iter()
+            .enumerate()
+        {
             if let Some(pos) = pos {
                 let x = pos.x().ceil() as usize;
                 let y = pos.y().ceil() as usize;
-                buf[idx + 1] = anime.0[y][x];
+                buf[idx + 1] = anime.data[y][x];
             }
         }
-        AnimeDataBuffer::from_vec(buf)
+        AnimeDataBuffer::from_vec(anime.anime_type, buf)
     }
 }
 
@@ -113,7 +118,7 @@ mod tests {
 
     #[test]
     fn check_data_alignment() {
-        let mut matrix = AnimeGrid::new(None);
+        let mut matrix = AnimeGrid::new(AnimeType::GA401);
         {
             let tmp = matrix.get_mut();
             for row in tmp.iter_mut() {
@@ -122,7 +127,7 @@ mod tests {
             }
         }
 
-        let matrix = <AnimeDataBuffer>::from(matrix);
+        let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
 
         let data_cmp = [
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -171,6 +176,6 @@ mod tests {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0,
             0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         ];
-        assert_eq!(matrix.get(), &data_cmp);
+        assert_eq!(matrix.data(), &data_cmp);
     }
 }

rog-anime/src/lib.rs

@@ -32,4 +32,4 @@ pub mod error;
 /// Provides const methods to create the USB HID control packets
 pub mod usb;
 
-pub static VERSION: &str = env!("CARGO_PKG_VERSION");
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");

rog-anime/src/sequencer.rs

@@ -1,9 +1,11 @@
-use std::{path::PathBuf, time::Duration};
-
 use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
+use std::convert::TryFrom;
+use std::{path::PathBuf, time::Duration};
 
-use crate::{error::AnimeError, AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage};
+use crate::{
+    error::Result, AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType,
+};
 
 /// All the possible AniMe actions that can be used. This enum is intended to be
 /// a helper for loading up `ActionData`.
@@ -63,24 +65,34 @@ pub enum ActionData {
 }
 
 impl ActionData {
-    pub fn from_anime_action(action: &ActionLoader) -> Result<ActionData, AnimeError> {
+    pub fn from_anime_action(anime_type: AnimeType, action: &ActionLoader) -> Result<ActionData> {
         let a = match action {
             ActionLoader::AsusAnimation {
                 file,
                 time,
                 brightness,
-            } => ActionData::Animation(AnimeGif::from_diagonal_gif(file, *time, *brightness)?),
+            } => ActionData::Animation(AnimeGif::from_diagonal_gif(
+                file,
+                *time,
+                *brightness,
+                anime_type,
+            )?),
             ActionLoader::AsusImage {
                 file,
                 time,
                 brightness,
             } => match time {
                 AnimTime::Infinite => {
-                    let image = AnimeDiagonal::from_png(file, None, *brightness)?;
-                    let data = <AnimeDataBuffer>::from(&image);
+                    let image = AnimeDiagonal::from_png(file, None, *brightness, anime_type)?;
+                    let data = image.into_data_buffer(anime_type)?;
                     ActionData::Image(Box::new(data))
                 }
-                _ => ActionData::Animation(AnimeGif::from_diagonal_png(file, *time, *brightness)?),
+                _ => ActionData::Animation(AnimeGif::from_diagonal_png(
+                    file,
+                    anime_type,
+                    *time,
+                    *brightness,
+                )?),
             },
             ActionLoader::ImageAnimation {
                 file,
@@ -99,6 +111,7 @@ impl ActionData {
                             *translation,
                             *time,
                             *brightness,
+                            anime_type,
                         )?));
                     }
                 }
@@ -109,6 +122,7 @@ impl ActionData {
                     *translation,
                     *time,
                     *brightness,
+                    anime_type,
                 )?)
             }
             ActionLoader::Image {
@@ -122,9 +136,15 @@ impl ActionData {
                 match time {
                     AnimTime::Infinite => {
                         // If no time then create a plain static image
-                        let image =
-                            AnimeImage::from_png(file, *scale, *angle, *translation, *brightness)?;
-                        let data = <AnimeDataBuffer>::from(&image);
+                        let image = AnimeImage::from_png(
+                            file,
+                            *scale,
+                            *angle,
+                            *translation,
+                            *brightness,
+                            anime_type,
+                        )?;
+                        let data = <AnimeDataBuffer>::try_from(&image)?;
                         ActionData::Image(Box::new(data))
                     }
                     _ => ActionData::Animation(AnimeGif::from_png(
@@ -134,6 +154,7 @@ impl ActionData {
                         *translation,
                         *time,
                         *brightness,
+                        anime_type,
                     )?),
                 }
             }
@@ -144,20 +165,21 @@ impl ActionData {
 }
 
 /// An optimised precomputed set of actions that the user can cycle through
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct Sequences(Vec<ActionData>);
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Sequences(Vec<ActionData>, AnimeType);
 
 impl Sequences {
     #[inline]
-    pub fn new() -> Self {
-        Self(Vec::new())
+    pub fn new(anime_type: AnimeType) -> Self {
+        Self(Vec::new(), anime_type)
     }
 
     /// Use a base `AnimeAction` to generate the precomputed data and insert in to
     /// the run buffer
     #[inline]
-    pub fn insert(&mut self, index: usize, action: &ActionLoader) -> Result<(), AnimeError> {
-        self.0.insert(index, ActionData::from_anime_action(action)?);
+    pub fn insert(&mut self, index: usize, action: &ActionLoader) -> Result<()> {
+        self.0
+            .insert(index, ActionData::from_anime_action(self.1, action)?);
         Ok(())
     }
 

rog-anime/src/usb.rs

@@ -7,6 +7,8 @@
 //!
 //! Step 1 need to applied only on fresh system boot.
 
+use crate::{error::AnimeError, AnimeType};
+
 const INIT_STR: [u8; 15] = [
     0x5e, b'A', b'S', b'U', b'S', b' ', b'T', b'e', b'c', b'h', b'.', b'I', b'n', b'c', b'.',
 ];
@@ -15,6 +17,23 @@ const DEV_PAGE: u8 = 0x5e;
 pub const VENDOR_ID: u16 = 0x0b05;
 pub const PROD_ID: u16 = 0x193b;
 
+/// `get_anime_type` is very broad, matching on part of the laptop board name only. For this
+/// reason `find_node()` must be used also to verify if the USB device is available.
+///
+/// The currently known USB device is `19b6`.
+#[inline]
+pub fn get_anime_type() -> Result<AnimeType, AnimeError> {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name()?;
+
+    if board_name.contains("GA401I") || board_name.contains("GA401Q") {
+        return Ok(AnimeType::GA401);
+    } else if board_name.contains("GA402R") {
+        return Ok(AnimeType::GA402);
+    }
+    Err(AnimeError::UnsupportedDevice)
+}
+
 /// Get the two device initialization packets. These are required for device start
 /// after the laptop boots.
 #[inline]

rog-aura/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_aura"
-version = "1.1.0"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -9,16 +9,18 @@ homepage = "https://gitlab.com/asus-linux/asusctl"
 documentation = "https://docs.rs/rog-anime"
 description = "Types useful for fancy keyboards on ASUS ROG laptops"
 keywords = ["ROG", "ASUS", "Aura"]
-edition = "2018"
+edition = "2021"
 exclude = ["data"]
 
 [features]
-default = ["dbus"]
-dbus = ["zvariant", "zvariant_derive"]
+default = ["dbus", "toml"]
+dbus = ["zvariant"]
 
 [dependencies]
-serde = "^1.0"
-serde_derive = "^1.0"
+serde.workspace = true
+serde_derive.workspace = true
+toml = { workspace = true, optional = true }
+zvariant = { workspace = true, optional = true }
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+[dev-dependencies]
+serde_json.workspace = true

rog-aura/data/layouts/g513_US.toml

@@ -0,0 +1,161 @@
+matches = [
+    'G513',
+]
+
+locale = "US"
+
+[[rows]]
+height = 0.8
+row = [
+    'NormalSpacer',
+    'FuncSpacer',
+    'VolDown',
+    'VolUp',
+    'MicMute',
+    'Fan',
+    'Rog',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'Esc',
+    'FuncSpacer',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'FuncSpacer',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'FuncSpacer',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+    'RowEndSpacer',
+    'NumPadDel',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tilde',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'N8',
+    'N9',
+    'N0',
+    'Hyphen',
+    'Equals',
+    'BkSpc',
+    'RowEndSpacer',
+    'Home',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tab',
+    'Q',
+    'W',
+    'E',
+    'R',
+    'T',
+    'Y',
+    'U',
+    'I',
+    'O',
+    'P',
+    'LBracket',
+    'RBracket',
+    'BackSlash',
+    'RowEndSpacer',
+    'PgUp',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Caps',
+    'A',
+    'S',
+    'D',
+    'F',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'SemiColon',
+    'Quote',
+    'Return',
+    'RowEndSpacer',
+    'PgDn',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LShift',
+    'Z',
+    'X',
+    'C',
+    'V',
+    'B',
+    'N',
+    'M',
+    'Comma',
+    'Period',
+    'FwdSlash',
+    'Rshift',
+    'RowEndSpacer',
+    'End',
+]
+
+[[rows]]
+height = 1.2
+row = [
+    'LCtrl',
+    'LFn',
+    'Meta',
+    'LAlt',
+    'Space',
+    'RAlt',
+    'PrtSc',
+    'RCtrl',
+    'ArrowSpacer',
+    'Up',
+    'ArrowSpacer',
+    'RowEndSpacer',
+    'RFn',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'ArrowSpacer',
+    'Left',
+    'Down',
+    'Right',
+    'ArrowSpacer',
+]

rog-aura/data/layouts/g533_US.toml

@@ -0,0 +1,135 @@
+matches = [
+    'G533',
+]
+
+locale = "US"
+
+[[rows]]
+height = 0.8
+row = [
+    'NormalSpacer',
+    'FuncSpacer',
+    'VolDown',
+    'VolUp',
+    'MicMute',
+    'Fan',
+    'Rog',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'Esc',
+    'FuncSpacer',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'FuncSpacer',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'FuncSpacer',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+    'Del',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tilde',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'N8',
+    'N9',
+    'N0',
+    'Hyphen',
+    'Equals',
+    'BkSpc',
+    'MediaPlay',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tab',
+    'Q',
+    'W',
+    'E',
+    'R',
+    'T',
+    'Y',
+    'U',
+    'I',
+    'O',
+    'P',
+    'LBracket',
+    'RBracket',
+    'BackSlash',
+    'MediaStop',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Caps',
+    'A',
+    'S',
+    'D',
+    'F',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'SemiColon',
+    'Quote',
+    'Return',
+    'MediaPrev',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LShift',
+    'Z',
+    'X',
+    'C',
+    'V',
+    'B',
+    'N',
+    'M',
+    'Comma',
+    'Period',
+    'FwdSlash',
+    'RshiftSmall',
+    'UpRegular',
+    'MediaNext',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LCtrlMed',
+    'LFn',
+    'Meta',
+    'LAlt',
+    'Space',
+    'RAlt',
+    'PrtSc',
+    'RCtrl',
+    'ArrowRegularSpacer',
+    'LeftRegular',
+    'DownRegular',
+    'RightRegular',
+]
+

rog-aura/data/layouts/ga401_US.toml

@@ -0,0 +1,154 @@
+matches = [
+    'GA401',
+    'GA402',
+    'GU603',
+    'GV301',
+    'GA502',
+    'GA503',
+]
+
+locale = "US"
+
+[[rows]]
+height = 0.8
+row = [
+    'NormalSpacer',
+    'FuncSpacer',
+    'VolDown',
+    'VolUp',
+    'MicMute',
+    'Rog',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'Esc',
+    'FuncSpacer',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'FuncSpacer',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'FuncSpacer',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tilde',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'N8',
+    'N9',
+    'N0',
+    'Hyphen',
+    'Equals',
+    'BkSpc',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tab',
+    'Q',
+    'W',
+    'E',
+    'R',
+    'T',
+    'Y',
+    'U',
+    'I',
+    'O',
+    'P',
+    'LBracket',
+    'RBracket',
+    'BackSlash',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Caps',
+    'A',
+    'S',
+    'D',
+    'F',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'SemiColon',
+    'Quote',
+    'Return',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LShift',
+    'Z',
+    'X',
+    'C',
+    'V',
+    'B',
+    'N',
+    'M',
+    'Comma',
+    'Period',
+    'FwdSlash',
+    'Rshift',
+]
+
+[[rows]]
+height = 1.2
+row = [
+    'LCtrl',
+    'LFn',
+    'Meta',
+    'LAlt',
+    'Space',
+    'RAlt',
+    'PrtSc',
+    'RCtrl',
+    'ArrowSpacer',
+    'Up',
+    'ArrowSpacer',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'FuncSpacer',
+    'FuncSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'Left',
+    'Down',
+    'Right',
+    'ArrowSpacer',
+]
+

rog-aura/data/layouts/gl504_US.toml

@@ -0,0 +1,180 @@
+matches = [
+    'GL504',
+]
+
+locale = "US"
+
+[[rows]]
+height = 0.8
+row = [
+    'NormalSpacer',
+    'FuncSpacer',
+    'VolDown',
+    'VolUp',
+    'MicMute',
+    'Rog',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'Esc',
+    'FuncSpacer',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'FuncSpacer',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'FuncSpacer',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+    'RowEndSpacer',
+    'Del',
+    'NumPadPause',
+    'NumPadPrtSc',
+    'NumPadHome',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tilde',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'N8',
+    'N9',
+    'N0',
+    'Hyphen',
+    'Equals',
+    'BkSpc',
+    'RowEndSpacer',
+    'NumLock',
+    'FwdSlash',
+    'Star',
+    'Hyphen',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tab',
+    'Q',
+    'W',
+    'E',
+    'R',
+    'T',
+    'Y',
+    'U',
+    'I',
+    'O',
+    'P',
+    'LBracket',
+    'RBracket',
+    'BackSlash',
+    'RowEndSpacer',
+    'N7',
+    'N8',
+    'N9',
+    'NumPadPlus',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Caps',
+    'A',
+    'S',
+    'D',
+    'F',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'SemiColon',
+    'Quote',
+    'Return',
+    'RowEndSpacer',
+    'N4',
+    'N5',
+    'N6',
+    'NumPadPlus',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LShift',
+    'Z',
+    'X',
+    'C',
+    'V',
+    'B',
+    'N',
+    'M',
+    'Comma',
+    'Period',
+    'FwdSlash',
+    'Rshift',
+    'RowEndSpacer',
+    'N1',
+    'N2',
+    'N3',
+    'NumPadEnter',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LCtrl',
+    'LFn',
+    'Meta',
+    'LAlt',
+    'Space',
+    'RAlt',
+    'RFn',
+    'RFn',
+    'RCtrlLarge',
+    'RowEndSpacer',
+    'UpRegular',
+    'N0',
+    'NumPadDel',
+    'NumPadEnter',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'FuncSpacer',
+    'FuncSpacer',
+    'FuncSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'LeftRegular',
+    'RowEndSpacer',
+    'DownRegular',
+    'RightRegular',
+    'NormalSpacer',
+]
+

rog-aura/data/layouts/gx502_US.toml

@@ -0,0 +1,172 @@
+matches = [
+    'GX502',
+    'GU502',
+]
+
+locale = "US"
+
+[[rows]]
+height = 0.8
+row = [
+    'NormalSpacer',
+    'FuncSpacer',
+    'VolDown',
+    'VolUp',
+    'MicMute',
+    'Rog',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'Esc',
+    'FuncSpacer',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'FuncSpacer',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'FuncSpacer',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+    'RowEndSpacer',
+    'Del',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tilde',
+    'N1',
+    'N2',
+    'N3',
+    'N4',
+    'N5',
+    'N6',
+    'N7',
+    'N8',
+    'N9',
+    'N0',
+    'Hyphen',
+    'Equals',
+    'BkSpc3_1',
+    'BkSpc3_2',
+    'BkSpc3_3',
+    'RowEndSpacer',
+    'Home',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Tab',
+    'Q',
+    'W',
+    'E',
+    'R',
+    'T',
+    'Y',
+    'U',
+    'I',
+    'O',
+    'P',
+    'LBracket',
+    'RBracket',
+    'BackSlash',
+    'RowEndSpacer',
+    'PgUp',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'Caps',
+    'A',
+    'S',
+    'D',
+    'F',
+    'G',
+    'H',
+    'J',
+    'K',
+    'L',
+    'SemiColon',
+    'Quote',
+    'Return3_1',
+    'Return3_2',
+    'Return3_3',
+    'RowEndSpacer',
+    'PgDn',
+]
+
+[[rows]]
+height = 1.0
+row = [
+    'LShift',
+    'Z',
+    'X',
+    'C',
+    'V',
+    'B',
+    'N',
+    'M',
+    'Comma',
+    'Period',
+    'FwdSlash',
+    'Rshift3_1',
+    'Rshift3_2',
+    'Rshift3_3',
+    'RowEndSpacer',
+    'End',
+]
+
+[[rows]]
+height = 1.2
+row = [
+    'LCtrl',
+    'LFn',
+    'Meta',
+    'LAlt',
+    'Space5_1',
+    'Space5_2',
+    'Space5_3',
+    'Space5_4',
+    'Space5_5',
+    'RAlt',
+    'PrtSc',
+    'RCtrl',
+    'ArrowSpacer',
+    'Up',
+    'ArrowSpacer',
+    'RowEndSpacer',
+    'RFn',
+]
+
+[[rows]]
+height = 0.8
+row = [
+    'FuncSpacer',
+    'FuncSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'NormalSpacer',
+    'Left',
+    'Down',
+    'Right',
+    'ArrowSpacer',
+]
+

rog-aura/src/builtin_modes.rs

@@ -7,19 +7,12 @@ pub const LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
 use serde_derive::{Deserialize, Serialize};
 use std::str::FromStr;
 #[cfg(feature = "dbus")]
-use zvariant_derive::Type;
+use zvariant::Type;
 
 use crate::{error::Error, LED_MSG_LEN};
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
-pub struct LedPowerStates {
-    pub enabled: bool,
-    pub sleep_anim_enabled: bool,
-}
-
-#[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum LedBrightness {
     Off,
     Low,
@@ -27,13 +20,6 @@ pub enum LedBrightness {
     High,
 }
 
-impl LedBrightness {
-    pub fn as_char_code(&self) -> u8 {
-        std::char::from_digit(*self as u32, 10)
-            .expect("LedBrightness.as_char_code failed to convert") as u8
-    }
-}
-
 impl From<u32> for LedBrightness {
     fn from(bright: u32) -> Self {
         match bright {
@@ -47,7 +33,7 @@ impl From<u32> for LedBrightness {
 }
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Clone, PartialEq, Copy, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Copy, Deserialize, Serialize)]
 pub struct Colour(pub u8, pub u8, pub u8);
 
 impl Default for Colour {
@@ -70,8 +56,36 @@ impl FromStr for Colour {
     }
 }
 
+impl From<&[f32; 3]> for Colour {
+    fn from(c: &[f32; 3]) -> Self {
+        Self(
+            (255.0 * c[0]) as u8,
+            (255.0 * c[1]) as u8,
+            (255.0 * c[2]) as u8,
+        )
+    }
+}
+
+impl From<Colour> for [f32; 3] {
+    fn from(c: Colour) -> Self {
+        [c.0 as f32 / 255.0, c.1 as f32 / 255.0, c.2 as f32 / 255.0]
+    }
+}
+
+impl From<&[u8; 3]> for Colour {
+    fn from(c: &[u8; 3]) -> Self {
+        Self(c[0], c[1], c[2])
+    }
+}
+
+impl From<Colour> for [u8; 3] {
+    fn from(c: Colour) -> Self {
+        [c.0, c.1, c.2]
+    }
+}
+
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Speed {
     Low = 0xe1,
     Med = 0xeb,
@@ -96,11 +110,20 @@ impl FromStr for Speed {
     }
 }
 
+impl From<Speed> for u8 {
+    fn from(s: Speed) -> u8 {
+        match s {
+            Speed::Low => 0,
+            Speed::Med => 1,
+            Speed::High => 2,
+        }
+    }
+}
 /// Used for Rainbow mode.
 ///
 /// Enum corresponds to the required integer value
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Direction {
     Right,
     Left,
@@ -129,8 +152,11 @@ impl FromStr for Direction {
 
 /// Enum of modes that convert to the actual number required by a USB HID packet
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Deserialize, Serialize)]
+#[derive(
+    Debug, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Deserialize, Serialize,
+)]
 pub enum AuraModeNum {
+    #[default]
     Static = 0,
     Breathe = 1,
     Strobe = 2,
@@ -145,18 +171,38 @@ pub enum AuraModeNum {
     Flash = 12,
 }
 
+impl From<AuraModeNum> for String {
+    fn from(mode: AuraModeNum) -> Self {
+        match mode {
+            AuraModeNum::Static => "Static",
+            AuraModeNum::Breathe => "Breathe",
+            AuraModeNum::Strobe => "Strobe",
+            AuraModeNum::Rainbow => "Rainbow",
+            AuraModeNum::Star => "Stars",
+            AuraModeNum::Rain => "Rain",
+            AuraModeNum::Highlight => "Highlight",
+            AuraModeNum::Laser => "Laser",
+            AuraModeNum::Ripple => "Ripple",
+            AuraModeNum::Pulse => "Pulse",
+            AuraModeNum::Comet => "Comet",
+            AuraModeNum::Flash => "Flash",
+        }
+        .to_string()
+    }
+}
+
 impl From<&AuraModeNum> for &str {
     fn from(mode: &AuraModeNum) -> Self {
         match mode {
             AuraModeNum::Static => "Static",
-            AuraModeNum::Breathe => "Breathing",
-            AuraModeNum::Strobe => "Strobing",
+            AuraModeNum::Breathe => "Breathe",
+            AuraModeNum::Strobe => "Strobe",
             AuraModeNum::Rainbow => "Rainbow",
             AuraModeNum::Star => "Stars",
             AuraModeNum::Rain => "Rain",
-            AuraModeNum::Highlight => "Keypress Highlight",
-            AuraModeNum::Laser => "Keypress Laser",
-            AuraModeNum::Ripple => "Keypress Ripple",
+            AuraModeNum::Highlight => "Highlight",
+            AuraModeNum::Laser => "Laser",
+            AuraModeNum::Ripple => "Ripple",
             AuraModeNum::Pulse => "Pulse",
             AuraModeNum::Comet => "Comet",
             AuraModeNum::Flash => "Flash",
@@ -167,14 +213,14 @@ impl From<&str> for AuraModeNum {
     fn from(mode: &str) -> Self {
         match mode {
             "Static" => AuraModeNum::Static,
-            "Breathing" => AuraModeNum::Breathe,
-            "Strobing" => AuraModeNum::Strobe,
+            "Breathe" => AuraModeNum::Breathe,
+            "Strobe" => AuraModeNum::Strobe,
             "Rainbow" => AuraModeNum::Rainbow,
             "Stars" => AuraModeNum::Star,
             "Rain" => AuraModeNum::Rain,
-            "Keypress Highlight" => AuraModeNum::Highlight,
-            "Keypress Laser" => AuraModeNum::Laser,
-            "Keypress Ripple" => AuraModeNum::Ripple,
+            "Highlight" => AuraModeNum::Highlight,
+            "Laser" => AuraModeNum::Laser,
+            "Ripple" => AuraModeNum::Ripple,
             "Pulse" => AuraModeNum::Pulse,
             "Comet" => AuraModeNum::Comet,
             "Flash" => AuraModeNum::Flash,
@@ -205,18 +251,57 @@ impl From<u8> for AuraModeNum {
 
 /// Base effects have no zoning, while multizone is 1-4
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum AuraZone {
+    /// Used if keyboard has no zones, or if setting all
+    #[default]
     None,
-    One,
-    Two,
-    Three,
-    Four,
+    /// Leftmost zone
+    Key1,
+    /// Zone after leftmost
+    Key2,
+    /// Zone second from right
+    Key3,
+    /// Rightmost zone
+    Key4,
+    /// Logo on the lid (or elsewhere?)
+    Logo,
+    /// The left part of a lightbar (typically on the front of laptop)
+    BarLeft,
+    /// The right part of a lightbar
+    BarRight,
+}
+
+impl FromStr for AuraZone {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.to_ascii_lowercase().as_str() {
+            "0" => Ok(AuraZone::None),
+            "none" => Ok(AuraZone::None),
+            "1" => Ok(AuraZone::Key1),
+            "one" => Ok(AuraZone::Key1),
+            "2" => Ok(AuraZone::Key2),
+            "two" => Ok(AuraZone::Key2),
+            "3" => Ok(AuraZone::Key3),
+            "three" => Ok(AuraZone::Key3),
+            "4" => Ok(AuraZone::Key4),
+            "four" => Ok(AuraZone::Key4),
+            "5" => Ok(AuraZone::Logo),
+            "logo" => Ok(AuraZone::Logo),
+            "6" => Ok(AuraZone::BarLeft),
+            "lightbar-left" => Ok(AuraZone::BarLeft),
+            "7" => Ok(AuraZone::BarRight),
+            "lightbar-right" => Ok(AuraZone::BarRight),
+            _ => Err(Error::ParseSpeed),
+        }
+    }
 }
 
 /// Default factory modes structure. This easily converts to an USB HID packet with:
 /// ```rust
-/// let bytes: [u8; LED_MSG_LEN] = mode.into();
+/// // let bytes: [u8; LED_MSG_LEN] = mode.into();
 /// ```
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -240,8 +325,8 @@ impl AuraEffect {
         &self.mode
     }
 
-    pub fn mode_name(&self) -> String {
-        (<&str>::from(&self.mode)).to_string()
+    pub fn mode_name(&self) -> &str {
+        <&str>::from(&self.mode)
     }
 
     pub fn mode_num(&self) -> u8 {
@@ -273,6 +358,53 @@ impl Default for AuraEffect {
     }
 }
 
+pub struct AuraParameters {
+    pub zone: bool,
+    pub colour1: bool,
+    pub colour2: bool,
+    pub speed: bool,
+    pub direction: bool,
+}
+
+impl AuraParameters {
+    pub const fn new(
+        zone: bool,
+        colour1: bool,
+        colour2: bool,
+        speed: bool,
+        direction: bool,
+    ) -> Self {
+        Self {
+            zone,
+            colour1,
+            colour2,
+            speed,
+            direction,
+        }
+    }
+}
+
+impl AuraEffect {
+    /// A helper to provide detail on what effects have which parameters, e.g the static
+    /// factory mode accepts only one colour.
+    pub const fn allowed_parameters(mode: AuraModeNum) -> AuraParameters {
+        match mode {
+            AuraModeNum::Static => AuraParameters::new(true, true, false, false, false),
+            AuraModeNum::Breathe => AuraParameters::new(true, true, true, true, false),
+            AuraModeNum::Strobe => AuraParameters::new(true, false, false, true, false),
+            AuraModeNum::Rainbow => AuraParameters::new(true, false, false, true, true),
+            AuraModeNum::Star => AuraParameters::new(true, true, true, true, true),
+            AuraModeNum::Rain => AuraParameters::new(true, false, false, true, false),
+            AuraModeNum::Highlight => AuraParameters::new(true, true, false, false, false),
+            AuraModeNum::Laser => AuraParameters::new(true, true, false, true, false),
+            AuraModeNum::Ripple => AuraParameters::new(true, true, false, true, false),
+            AuraModeNum::Pulse => AuraParameters::new(true, true, false, false, false),
+            AuraModeNum::Comet => AuraParameters::new(true, true, false, false, false),
+            AuraModeNum::Flash => AuraParameters::new(true, true, false, false, false),
+        }
+    }
+}
+
 /// Parses `AuraEffect` in to packet data for writing to the USB interface
 ///
 /// Byte structure where colour is RGB, one byte per R, G, B:
@@ -299,3 +431,119 @@ impl From<&AuraEffect> for [u8; LED_MSG_LEN] {
         msg
     }
 }
+
+impl From<&AuraEffect> for Vec<u8> {
+    fn from(aura: &AuraEffect) -> Self {
+        let mut msg = vec![0u8; LED_MSG_LEN];
+        msg[0] = 0x5d;
+        msg[1] = 0xb3;
+        msg[2] = aura.zone as u8;
+        msg[3] = aura.mode as u8;
+        msg[4] = aura.colour1.0;
+        msg[5] = aura.colour1.1;
+        msg[6] = aura.colour1.2;
+        msg[7] = aura.speed as u8;
+        msg[8] = aura.direction as u8;
+        msg[10] = aura.colour2.0;
+        msg[11] = aura.colour2.1;
+        msg[12] = aura.colour2.2;
+        msg
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed, LED_MSG_LEN};
+
+    #[test]
+    fn check_led_static_packet() {
+        let st = AuraEffect {
+            mode: AuraModeNum::Static,
+            zone: AuraZone::None,
+            colour1: Colour(0xff, 0x11, 0xdd),
+            colour2: Colour::default(),
+            speed: Speed::Med,
+            direction: Direction::Right,
+        };
+        let ar = <[u8; LED_MSG_LEN]>::from(&st);
+
+        println!("{:02x?}", ar);
+        let check = [
+            0x5d, 0xb3, 0x0, 0x0, 0xff, 0x11, 0xdd, 0xeb, 0x0, 0x0, 0xa6, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        assert_eq!(ar, check);
+    }
+
+    #[test]
+    fn check_led_static_zone_packet() {
+        let mut st = AuraEffect {
+            mode: AuraModeNum::Static,
+            zone: AuraZone::Key1,
+            colour1: Colour(0xff, 0, 0),
+            colour2: Colour(0, 0, 0),
+            speed: Speed::Low,
+            direction: Direction::Left,
+        };
+        let capture = [
+            0x5d, 0xb3, 0x01, 0x00, 0xff, 0x00, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key2;
+        st.colour1 = Colour(0xff, 0xff, 0);
+        let capture = [
+            0x5d, 0xb3, 0x02, 0x00, 0xff, 0xff, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key3;
+        st.colour1 = Colour(0, 0xff, 0xff);
+        let capture = [
+            0x5d, 0xb3, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key4;
+        st.colour1 = Colour(0xff, 0x00, 0xff);
+        let capture = [
+            0x5d, 0xb3, 0x04, 0x00, 0xff, 0x00, 0xff, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Logo;
+        st.colour1 = Colour(0x2c, 0xff, 0x00);
+        let capture = [
+            0x5d, 0xb3, 0x05, 0x00, 0x2c, 0xff, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::BarLeft;
+        st.colour1 = Colour(0xff, 0x00, 0x00);
+        let capture = [
+            0x5d, 0xb3, 0x06, 0x00, 0xff, 0x00, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::BarRight;
+        st.colour1 = Colour(0xff, 0x00, 0xcd);
+        let capture = [
+            0x5d, 0xb3, 0x07, 0x00, 0xff, 0x00, 0xcd, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.mode = AuraModeNum::Rainbow;
+        let capture = [
+            0x5d, 0xb3, 0x07, 0x03, 0xff, 0x00, 0xcd, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+    }
+}

rog-aura/src/error.rs

@@ -7,7 +7,8 @@ pub enum Error {
     ParseSpeed,
     ParseDirection,
     ParseBrightness,
-    ParseAnime,
+    Io(std::io::Error),
+    Toml(toml::de::Error),
 }
 
 impl fmt::Display for Error {
@@ -18,9 +19,22 @@ impl fmt::Display for Error {
             Error::ParseSpeed => write!(f, "Could not parse speed"),
             Error::ParseDirection => write!(f, "Could not parse direction"),
             Error::ParseBrightness => write!(f, "Could not parse brightness"),
-            Error::ParseAnime => write!(f, "Could not parse anime"),
+            Error::Io(io) => write!(f, "IO Error: {io}"),
+            Error::Toml(e) => write!(f, "TOML Parse Error: {e}"),
         }
     }
 }
 
 impl error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(e: std::io::Error) -> Self {
+        Self::Io(e)
+    }
+}
+
+impl From<toml::de::Error> for Error {
+    fn from(e: toml::de::Error) -> Self {
+        Self::Toml(e)
+    }
+}

rog-aura/src/key_to_str.rs

@@ -0,0 +1,155 @@
+use crate::keys::Key;
+
+impl From<Key> for &str {
+    fn from(k: Key) -> Self {
+        (&k).into()
+    }
+}
+
+impl From<&Key> for &str {
+    fn from(k: &Key) -> Self {
+        match k {
+            Key::VolUp => "Volume Up",
+            Key::VolDown => "Volume Down",
+            Key::MicMute => "Mute Mic",
+            Key::Rog => "ROG",
+            Key::Fan => "Fan Control",
+            Key::Esc => "Escape",
+            Key::F1 => "F1",
+            Key::F2 => "F2",
+            Key::F3 => "F3",
+            Key::F4 => "F4",
+            Key::F5 => "F5",
+            Key::F6 => "F6",
+            Key::F7 => "F7",
+            Key::F8 => "F8",
+            Key::F9 => "F9",
+            Key::F10 => "F10",
+            Key::F11 => "F11",
+            Key::F12 => "F12",
+            Key::Del => "Delete",
+            Key::Tilde => "Tilde",
+            Key::N1 => "1",
+            Key::N2 => "2",
+            Key::N3 => "3",
+            Key::N4 => "4",
+            Key::N5 => "5",
+            Key::N6 => "6",
+            Key::N7 => "7",
+            Key::N8 => "8",
+            Key::N9 => "9",
+            Key::N0 => "0",
+            Key::Hyphen => "-",
+            Key::Equals => "=",
+            Key::BkSpc => "Backspace",
+            Key::BkSpc3_1 => "Backspace LED 1",
+            Key::BkSpc3_2 => "Backspace LED 2",
+            Key::BkSpc3_3 => "Backspace LED 3",
+            Key::Home => "Home",
+            Key::Tab => "Tab",
+            Key::Q => "Q",
+            Key::W => "W",
+            Key::E => "E",
+            Key::R => "R",
+            Key::T => "T",
+            Key::Y => "Y",
+            Key::U => "U",
+            Key::I => "I",
+            Key::O => "O",
+            Key::P => "P",
+            Key::LBracket => "[",
+            Key::RBracket => "]",
+            Key::BackSlash => "\\",
+            Key::PgUp => "Page Up",
+            Key::Caps => "Caps Lock",
+            Key::A => "A",
+            Key::S => "S",
+            Key::D => "D",
+            Key::F => "F",
+            Key::G => "G",
+            Key::H => "H",
+            Key::J => "J",
+            Key::K => "K",
+            Key::L => "L",
+            Key::SemiColon => ";",
+            Key::Quote => "'",
+            Key::Return => "Return",
+            Key::Return3_1 => "Return LED 1",
+            Key::Return3_2 => "Return LED 2",
+            Key::Return3_3 => "Return LED 3",
+            Key::PgDn => "Page Down",
+            Key::LShift => "Left Shift",
+            Key::LShift3_1 => "Left Shift LED 1",
+            Key::LShift3_2 => "Left Shift LED 2",
+            Key::LShift3_3 => "Left Shift LED 3",
+            Key::Z => "Z",
+            Key::X => "X",
+            Key::C => "C",
+            Key::V => "V",
+            Key::B => "B",
+            Key::N => "N",
+            Key::M => "M",
+            Key::Comma => ",",
+            Key::Period => ".",
+            Key::Star => "*",
+            Key::NumPadDel => "Delete",
+            Key::NumPadPlus => "+",
+            Key::NumPadEnter => "Enter",
+            Key::NumPadPause => "Pause",
+            Key::NumPadPrtSc => "Print Screen",
+            Key::NumPadHome => "Home",
+            Key::NumLock => "Num-Lock",
+            Key::FwdSlash => "/",
+            Key::Rshift => "Right Shift",
+            Key::RshiftSmall => "Right Shift",
+            Key::Rshift3_1 => "Right Shift LED 1",
+            Key::Rshift3_2 => "Right Shift LED 2",
+            Key::Rshift3_3 => "Right Shift LED 3",
+            Key::End => "End",
+            Key::LCtrl => "Left Control",
+            Key::LCtrlMed => "Left Control",
+            Key::LFn => "Left Fn",
+            Key::Meta => "Meta",
+            Key::LAlt => "Left Alt",
+            Key::Space => "Space",
+            Key::Space5_1 => "Space LED 1",
+            Key::Space5_2 => "Space LED 2",
+            Key::Space5_3 => "Space LED 3",
+            Key::Space5_4 => "Space LED 4",
+            Key::Space5_5 => "Space LED 5",
+            Key::RAlt => "Right Alt",
+            Key::PrtSc => "Print Screen",
+            Key::RCtrl => "Right Control",
+            Key::RCtrlLarge => "Right Control",
+            Key::Pause => "Pause",
+            Key::Up => "Up",
+            Key::Down => "Down",
+            Key::Left => "Left",
+            Key::Right => "Right",
+            Key::UpRegular => "Up",
+            Key::DownRegular => "Down",
+            Key::LeftRegular => "Left",
+            Key::RightRegular => "Right",
+            Key::UpSplit => "Up",
+            Key::DownSplit => "Down",
+            Key::LeftSplit => "Left",
+            Key::RightSplit => "Right",
+            Key::RFn => "Right Fn",
+            Key::MediaPlay => "Media Play",
+            Key::MediaStop => "Media Stop",
+            Key::MediaNext => "Media Next",
+            Key::MediaPrev => "Media Previous",
+            Key::NormalBlank => "",
+            Key::NormalSpacer => "",
+            Key::FuncBlank => "",
+            Key::FuncSpacer => "",
+            Key::ArrowBlank => "",
+            Key::ArrowSpacer => "",
+            Key::ArrowRegularBlank => "",
+            Key::ArrowRegularSpacer => "",
+            Key::ArrowSplitBlank => "",
+            Key::ArrowSplitSpacer => "",
+            Key::RowEndSpacer => "",
+        }
+    }
+}

rog-aura/src/keys.rs

@@ -0,0 +1,356 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
+pub enum Key {
+    VolUp,
+    VolDown,
+    MicMute,
+    #[default]
+    Rog,
+    Fan,
+    Esc,
+    F1,
+    F2,
+    F3,
+    F4,
+    F5,
+    F6,
+    F7,
+    F8,
+    F9,
+    F10,
+    F11,
+    F12,
+    Del,
+    Tilde,
+    N1,
+    N2,
+    N3,
+    N4,
+    N5,
+    N6,
+    N7,
+    N8,
+    N9,
+    N0,
+    Hyphen,
+    Equals,
+    BkSpc,
+    BkSpc3_1,
+    BkSpc3_2,
+    BkSpc3_3,
+    Home,
+    Tab,
+    Q,
+    W,
+    E,
+    R,
+    T,
+    Y,
+    U,
+    I,
+    O,
+    P,
+    LBracket,
+    RBracket,
+    BackSlash,
+    PgUp,
+    Caps,
+    A,
+    S,
+    D,
+    F,
+    G,
+    H,
+    J,
+    K,
+    L,
+    SemiColon,
+    Quote,
+    Return,
+    Return3_1,
+    Return3_2,
+    Return3_3,
+    PgDn,
+    LShift,
+    LShift3_1,
+    LShift3_2,
+    LShift3_3,
+    Z,
+    X,
+    C,
+    V,
+    B,
+    N,
+    M,
+    Comma,
+    Period,
+    FwdSlash,
+    Star,
+    NumPadDel,
+    NumPadPlus,
+    NumPadEnter,
+    NumPadPause,
+    NumPadPrtSc,
+    NumPadHome,
+    NumLock,
+    Rshift,
+    RshiftSmall,
+    Rshift3_1,
+    Rshift3_2,
+    Rshift3_3,
+    End,
+    LCtrl,
+    LCtrlMed,
+    LFn,
+    Meta,
+    LAlt,
+    Space,
+    Space5_1,
+    Space5_2,
+    Space5_3,
+    Space5_4,
+    Space5_5,
+    Pause,
+    RAlt,
+    PrtSc,
+    RCtrl,
+    RCtrlLarge,
+    Up,
+    Down,
+    Left,
+    Right,
+    UpRegular,
+    DownRegular,
+    LeftRegular,
+    RightRegular,
+    UpSplit,
+    DownSplit,
+    LeftSplit,
+    RightSplit,
+    RFn,
+    MediaPlay,
+    MediaStop,
+    MediaNext,
+    MediaPrev,
+    NormalBlank,
+    /// To be ignored by per-key effects
+    NormalSpacer,
+    FuncBlank,
+    /// To be ignored by per-key effects
+    FuncSpacer,
+    ArrowBlank,
+    /// To be ignored by per-key effects
+    ArrowSpacer,
+    ArrowRegularBlank,
+    /// To be ignored by per-key effects
+    ArrowRegularSpacer,
+    ArrowSplitBlank,
+    /// To be ignored by per-key effects
+    ArrowSplitSpacer,
+    /// A gap between regular rows and the rightside buttons
+    RowEndSpacer,
+}
+
+impl Key {
+    pub fn is_placeholder(&self) -> bool {
+        let shape = KeyShape::from(self);
+        shape.is_blank() || shape.is_spacer()
+    }
+}
+
+/// Types of shapes of LED on keyboards. The shape is used for visual representations
+///
+/// A post fix of Spacer *must be ignored by per-key effects
+#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize)]
+pub enum KeyShape {
+    Tilde,
+    #[default]
+    Normal,
+    NormalBlank,
+    NormalSpacer,
+    Func,
+    FuncBlank,
+    FuncSpacer,
+    Space,
+    Space5,
+    LCtrlMed,
+    LShift,
+    /// Used in a group of 3 (LED's)
+    LShift3,
+    RShift,
+    RshiftSmall,
+    /// Used in a group of 3 (LED's)
+    RShift3,
+    Return,
+    Return3,
+    Tab,
+    Caps,
+    Backspace,
+    /// Used in a group of 3 (LED's)
+    Backspace3,
+    Arrow,
+    ArrowBlank,
+    ArrowSpacer,
+    ArrowSplit,
+    ArrowSplitBlank,
+    ArrowSplitSpacer,
+    ArrowRegularBlank,
+    ArrowRegularSpacer,
+    RowEndSpacer,
+}
+
+impl KeyShape {
+    pub const fn width(&self) -> f32 {
+        match self {
+            Self::Tilde => 0.8,
+            Self::Normal => 1.0,
+            Self::NormalBlank => 1.0,
+            Self::NormalSpacer => 1.0,
+            Self::Func => 1.0,
+            Self::FuncBlank => 1.0,
+            Self::FuncSpacer => 0.6,
+            Self::Space => 5.0,
+            Self::Space5 => 1.0,
+            Self::LCtrlMed => 1.1,
+            Self::LShift => 2.0,
+            Self::LShift3 => 0.67,
+            Self::RShift => 2.8,
+            Self::RshiftSmall => 1.8,
+            Self::RShift3 => 0.93,
+            Self::Return => 2.2,
+            Self::Return3 => 0.7333,
+            Self::Tab => 1.4,
+            Self::Caps => 1.6,
+            Self::Backspace => 2.0,
+            Self::Backspace3 => 0.666,
+            Self::ArrowRegularBlank | Self::ArrowRegularSpacer => 0.7,
+            Self::Arrow => 0.8,
+            Self::ArrowBlank | Self::ArrowSpacer => 1.0,
+            Self::ArrowSplit | Self::ArrowSplitBlank | Self::ArrowSplitSpacer => 1.0,
+            Self::RowEndSpacer => 0.1,
+        }
+    }
+
+    /// A blank is used to space keys out in GUI's and can be used or ignored
+    /// depednign on the per-key effect
+    pub const fn is_blank(&self) -> bool {
+        matches!(
+            self,
+            Self::NormalBlank
+                | Self::FuncBlank
+                | Self::ArrowBlank
+                | Self::ArrowSplitBlank
+                | Self::ArrowRegularBlank
+        )
+    }
+
+    /// A spacer is used to space keys out in GUI's, but ignored in per-key effects
+    pub const fn is_spacer(&self) -> bool {
+        matches!(
+            self,
+            Self::FuncSpacer
+                | Self::NormalSpacer
+                | Self::ArrowSpacer
+                | Self::ArrowSplitSpacer
+                | Self::ArrowRegularSpacer
+        )
+    }
+
+    /// All keys with a postfix of some number
+    pub const fn is_group(&self) -> bool {
+        matches!(
+            self,
+            Self::LShift3 | Self::RShift3 | Self::Return3 | Self::Space5 | Self::Backspace3
+        )
+    }
+
+    /// Mostly intended as a helper for signalling when to draw a
+    /// split/compact arrow cluster
+    pub const fn is_arrow_cluster(&self) -> bool {
+        matches!(self, Self::Arrow | Self::ArrowBlank | Self::ArrowSpacer)
+    }
+
+    pub const fn is_arrow_splits(&self) -> bool {
+        matches!(self, Self::Arrow | Self::ArrowBlank | Self::ArrowSpacer)
+    }
+}
+
+impl From<Key> for KeyShape {
+    fn from(k: Key) -> Self {
+        match k {
+            Key::VolUp
+            | Key::VolDown
+            | Key::MicMute
+            | Key::Rog
+            | Key::Fan
+            | Key::Esc
+            | Key::F1
+            | Key::F2
+            | Key::F3
+            | Key::F4
+            | Key::F5
+            | Key::F6
+            | Key::F7
+            | Key::F8
+            | Key::F9
+            | Key::F10
+            | Key::F11
+            | Key::F12
+            | Key::Del => KeyShape::Func,
+            Key::Tilde => KeyShape::Tilde,
+
+            Key::BkSpc => KeyShape::Backspace,
+            Key::BkSpc3_1 | Key::BkSpc3_2 | Key::BkSpc3_3 => KeyShape::Backspace3,
+            Key::Tab | Key::BackSlash => KeyShape::Tab,
+            Key::Caps => KeyShape::Caps,
+
+            Key::Return => KeyShape::Return,
+            Key::Return3_1 | Key::Return3_2 | Key::Return3_3 => KeyShape::Return3,
+            Key::LCtrlMed => KeyShape::LCtrlMed,
+            Key::LShift => KeyShape::LShift,
+
+            Key::Rshift | Key::RCtrlLarge => KeyShape::RShift,
+            Key::RshiftSmall => KeyShape::RshiftSmall,
+            Key::Rshift3_1 | Key::Rshift3_2 | Key::Rshift3_3 => KeyShape::RShift3,
+
+            Key::Space => KeyShape::Space,
+            Key::Space5_1 | Key::Space5_2 | Key::Space5_3 | Key::Space5_4 | Key::Space5_5 => {
+                KeyShape::Space5
+            }
+
+            Key::NumPadPause | Key::NumPadPrtSc | Key::NumPadHome | Key::NumPadDel => {
+                KeyShape::Func
+            }
+
+            Key::NormalBlank => KeyShape::NormalBlank,
+            Key::NormalSpacer => KeyShape::NormalSpacer,
+
+            Key::FuncBlank => KeyShape::FuncBlank,
+            Key::FuncSpacer => KeyShape::FuncSpacer,
+
+            Key::Up | Key::Down | Key::Left | Key::Right => KeyShape::Arrow,
+            Key::ArrowBlank => KeyShape::ArrowBlank,
+            Key::ArrowSpacer => KeyShape::ArrowSpacer,
+
+            Key::ArrowRegularBlank => KeyShape::ArrowRegularBlank,
+            Key::ArrowRegularSpacer => KeyShape::ArrowRegularSpacer,
+
+            Key::UpSplit | Key::LeftSplit | Key::DownSplit | Key::RightSplit => {
+                KeyShape::ArrowSplit
+            }
+            Key::ArrowSplitBlank => KeyShape::ArrowSplitBlank,
+            Key::ArrowSplitSpacer => KeyShape::ArrowSplitSpacer,
+
+            Key::RowEndSpacer => KeyShape::RowEndSpacer,
+
+            _ => KeyShape::Normal,
+        }
+    }
+}
+
+impl From<&Key> for KeyShape {
+    fn from(k: &Key) -> Self {
+        (*k).into()
+    }
+}

rog-aura/src/layouts/g513.rs

@@ -0,0 +1,170 @@
+use super::{KeyLayout, KeyRow};
+use crate::keys::Key;
+
+impl KeyLayout {
+    /// Similar to GX502, but not per-key enabled
+    pub fn g513_layout() -> Self {
+        Self {
+            matches: vec!["G513".into()],
+            locale: "US".to_string(),
+            rows: vec![
+                KeyRow::new(
+                    0.8,
+                    vec![
+                        Key::NormalSpacer,
+                        Key::FuncSpacer,
+                        Key::VolDown,
+                        Key::VolUp,
+                        Key::MicMute,
+                        Key::Fan,
+                        Key::Rog,
+                    ],
+                ),
+                KeyRow::new(
+                    0.8,
+                    vec![
+                        Key::Esc,
+                        Key::FuncSpacer,
+                        Key::F1,
+                        Key::F2,
+                        Key::F3,
+                        Key::F4,
+                        Key::FuncSpacer, // not sure which key to put here
+                        Key::F5,
+                        Key::F6,
+                        Key::F7,
+                        Key::F8,
+                        Key::FuncSpacer,
+                        Key::F9,
+                        Key::F10,
+                        Key::F11,
+                        Key::F12,
+                        Key::RowEndSpacer,
+                        Key::Del,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Tilde,
+                        Key::N1,
+                        Key::N2,
+                        Key::N3,
+                        Key::N4,
+                        Key::N5,
+                        Key::N6,
+                        Key::N7,
+                        Key::N8,
+                        Key::N9,
+                        Key::N0,
+                        Key::Hyphen,
+                        Key::Equals,
+                        Key::BkSpc,
+                        Key::RowEndSpacer,
+                        Key::Home,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Tab,
+                        Key::Q,
+                        Key::W,
+                        Key::E,
+                        Key::R,
+                        Key::T,
+                        Key::Y,
+                        Key::U,
+                        Key::I,
+                        Key::O,
+                        Key::P,
+                        Key::LBracket,
+                        Key::RBracket,
+                        Key::BackSlash,
+                        Key::RowEndSpacer,
+                        Key::PgUp,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Caps,
+                        Key::A,
+                        Key::S,
+                        Key::D,
+                        Key::F,
+                        Key::G,
+                        Key::H,
+                        Key::J,
+                        Key::K,
+                        Key::L,
+                        Key::SemiColon,
+                        Key::Quote,
+                        Key::Return,
+                        Key::RowEndSpacer,
+                        Key::PgDn,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::LShift,
+                        Key::Z,
+                        Key::X,
+                        Key::C,
+                        Key::V,
+                        Key::B,
+                        Key::N,
+                        Key::M,
+                        Key::Comma,
+                        Key::Period,
+                        Key::FwdSlash,
+                        Key::Rshift,
+                        Key::RowEndSpacer,
+                        Key::End,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::LCtrl,
+                        Key::LFn,
+                        Key::Meta,
+                        Key::LAlt,
+                        Key::Space,
+                        Key::RAlt,
+                        Key::PrtSc,
+                        Key::RCtrl,
+                        Key::ArrowSpacer,
+                        Key::Up,
+                        Key::ArrowSpacer,
+                        Key::RowEndSpacer,
+                        Key::RFn,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::Left,
+                        Key::Down,
+                        Key::Right,
+                        Key::ArrowSpacer,
+                    ],
+                ),
+            ],
+        }
+    }
+}

rog-aura/src/layouts/ga401.rs

@@ -0,0 +1,156 @@
+use super::{KeyLayout, KeyRow};
+use crate::keys::Key;
+
+impl KeyLayout {
+    pub fn ga401_layout() -> Self {
+        Self {
+            matches: vec!["GA401".into(), "GA402".into()],
+            locale: "US".to_string(),
+            rows: vec![
+                KeyRow::new(
+                    0.8,
+                    vec![
+                        Key::NormalSpacer,
+                        Key::FuncSpacer,
+                        Key::VolDown,
+                        Key::VolUp,
+                        Key::MicMute,
+                        Key::Rog,
+                    ],
+                ),
+                KeyRow::new(
+                    0.8,
+                    vec![
+                        Key::Esc,
+                        Key::FuncSpacer,
+                        Key::F1,
+                        Key::F2,
+                        Key::F3,
+                        Key::F4,
+                        Key::FuncSpacer, // not sure which key to put here
+                        Key::F5,
+                        Key::F6,
+                        Key::F7,
+                        Key::F8,
+                        Key::FuncSpacer,
+                        Key::F9,
+                        Key::F10,
+                        Key::F11,
+                        Key::F12,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Tilde,
+                        Key::N1,
+                        Key::N2,
+                        Key::N3,
+                        Key::N4,
+                        Key::N5,
+                        Key::N6,
+                        Key::N7,
+                        Key::N8,
+                        Key::N9,
+                        Key::N0,
+                        Key::Hyphen,
+                        Key::Equals,
+                        Key::BkSpc,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Tab,
+                        Key::Q,
+                        Key::W,
+                        Key::E,
+                        Key::R,
+                        Key::T,
+                        Key::Y,
+                        Key::U,
+                        Key::I,
+                        Key::O,
+                        Key::P,
+                        Key::LBracket,
+                        Key::RBracket,
+                        Key::BackSlash,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::Caps,
+                        Key::A,
+                        Key::S,
+                        Key::D,
+                        Key::F,
+                        Key::G,
+                        Key::H,
+                        Key::J,
+                        Key::K,
+                        Key::L,
+                        Key::SemiColon,
+                        Key::Quote,
+                        Key::Return,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::LShift,
+                        Key::Z,
+                        Key::X,
+                        Key::C,
+                        Key::V,
+                        Key::B,
+                        Key::N,
+                        Key::M,
+                        Key::Comma,
+                        Key::Period,
+                        Key::FwdSlash,
+                        Key::Rshift,
+                    ],
+                ),
+                KeyRow::new(
+                    1.0,
+                    vec![
+                        Key::LCtrl,
+                        Key::LFn,
+                        Key::Meta,
+                        Key::LAlt,
+                        Key::Space,
+                        Key::RAlt,
+                        Key::PrtSc,
+                        Key::RCtrl,
+                        Key::ArrowSpacer,
+                        Key::Up,
+                        Key::ArrowSpacer,
+                    ],
+                ),
+                KeyRow::new(
+                    1.2,
+                    vec![
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::ArrowSpacer,
+                        Key::Left,
+                        Key::Down,
+                        Key::Right,
+                        Key::ArrowSpacer,
+                    ],
+                ),
+            ],
+        }
+    }
+}