Update deps

Persistent dark / light mode

See merge request asus-linux/asusctl!160

.cargo-husky/hooks/pre-commit

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

.cargo-husky/hooks/pre-push

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

.editorconfig

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

.gitignore

@@ -1,2 +1,11 @@
 /target
-vendor.tar.xz
+vendor.tar.xz
+cargo-config
+.idea
+vendor
+vendor-*
+vendor_*
+.vscode-ctags
+.vscode
+.~lock.*
+*.ods# 

.gitlab-ci.yml

@@ -1,26 +1,84 @@
-image: rustdocker/rust:stable
+image: rust:latest
+
+.rust_cache: &rust_cache
+  cache:
+    # key: $CI_COMMIT_REF_SLUG
+    paths:
+      # Don't include `incremental` to save space
+      # Debug
+      - target/debug/build/
+      - target/debug/deps/
+      - target/debug/.fingerprint/
+      - target/debug/.cargo-lock
+      # Release
+      - target/release/build/
+      - target/release/deps/
+      - target/release/.fingerprint/
+      - target/release/.cargo-lock
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev
 
 stages:
-    - test
-    - build
+  - format
+  - check
+  - test
+  - release
+  - deploy
+
+format:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - echo "nightly" > rust-toolchain
+    - rustup component add rustfmt
+    - cargo fmt --check
+
+check:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - rustup component add clippy
+    - cargo check
+    # deny currently catches too much
+    #- cargo install cargo-deny && cargo deny
+    - cargo install cargo-cranky && cargo cranky
 
 test:
+  except:
+    - tags
+  <<: *rust_cache
   script:
-    - cargo check #+nightly check --features "clippy"
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test
 
-build:
+release:
   only:
-    - next
+    - tags
+  <<: *rust_cache
   script:
     - make && make vendor
   artifacts:
     paths:
-    - vendor_asus-nb-ctrl_*.tar.xz
+    - vendor_asusctl_*.tar.xz
     - cargo-config
 
+pages:
+  stage: deploy
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo doc --document-private-items --no-deps --workspace
+    - rm -rf public
+    - mkdir public
+    - cp -R target/doc/* public
+    - cp misc/index.html public
+  artifacts:
+    paths:
+      - public
+      
 variables:
   GIT_SUBMODULE_STRATEGY: normal
-

CHANGELOG.md

@@ -5,6 +5,591 @@ 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.6.2]
+- Fix rog-control-center not reopening if `startup_in_background` is set 
+
+## [v4.6.1]
+### Added
+- Support for G733Z LED modes
+- Support for GU604V LED modes
+- Support for GX650P LED modes
+- Support for GV604I LED modes
+- Support for FX516P LED modes (this laptop still has further issues, will require a patched kernel when patch is ready)
+- Add device code for the Z13 ACRNM keyboard (requires kernel patch, in progress)
+- Support for GV301VIC LED modes
+- Add device code for the plain Z13 keyboard (requires kernel patch, in progress)
+- Support for GV301V LED modes
+### Changed
+- Adjustments to Anime system events thread
+- Add "sleep" animetion config options to anime config
+- rog-control-center dark/light mode persistency
+- Adjustments to keyboard detection
+- Better support of using supergfxctl when available (tray icon and menu)
+- Check supergfx version before enabling use in tray (require 5.1.0+)
+- Update allowed Aura modes on asusd restart if changed
+- Set tray icon for dgpu to "On" if in Vfio mode to prevent confusion
+- Add support for Logout/Reboot in notification for KDE
+
+## [v4.6.0]
+### Added
+- Support for GL703GE keyboard layout
+- Support for G533Z modes and keyboard layout
+### Changed
+- Better handling of `/etc/asusd` not existing
+- Better handling of non-existant config files
+- Move all config handling to generic traits for better consistency
+- Re-parse all configs to RON format
+- Move fan-curve config to own config file
+- Added option to set `disable_nvidia_powerd_on_battery`
+- Add short log entry to throttle_thermal_policy change detection
+- ROGCC: Don't notify user if changing to same mux mode
+- ROGCC: Add CLI opt for loading a keyboard layout for testing, with live-reload on file change
+- ROGCC: Add CLI opt for viewing all layout files + filenames to help find a layout matching your laptop
+  + Both of these options would hopefully be temporary and replaced with a "wizard" GUI helper
+- Fix profile controller not detecting if platform_profile is changed
+- Fix remove the leftover initial config writes on `new()` for some controllers to prevent resetting settings on startup
+  + refactor the loading of systemd curve defaults and config file
+### BREAKING
+- Rename aura dbus method from `per_key_raw` to `direct_addressing_raw` and add doc comment
+- Changes to aura.conf:
+- Changes to asusd-ledmodes.toml:
+  + Rename `standard` to `basic_modes`
+  + Rename `multizone` to `basic_zones`
+  + Raname `per_key` to `advanced` and change type from `bool` to `AdvancedAuraType`
+  + Removed `prod_family`
+  + Split all entries to `board_name` (separating `board_names`) (now a huge file)
+  + removed `asusd-ledmodes.toml` in favour of `aura_support.ron` due to an unsupported type in toml
+- Rename and adjust `LedSupportedFunctions` to closely match the above
+
+## [v4.5.8]
+### Changed
+- Fix incorrect stop/start order of nvidia-powerd on AC plug/unplug
+
+## [v4.5.7]
+### Changed
+- ROGCC: Don't notify user if changing to same mux mode
+-
+
+## [v4.5.7]
+### Changed
+- ROGCC: Don't notify user if changing to same mux mode
+- asusd: don't block on systemd-unit change: removes all shoddy external command calls in favour of async dbus calls
+
+## [v4.5.6]
+### Changed
+- Fix tasks not always running correctly on boot/sleep/wake/shutdown by finishing the move to async
+- Change how the profile/fan change task monitors changes due to TUF laptops behaving slightly different
+- ROGCC: Better handle the use of GPU MUX without supergfxd
+- ROGCC: Track if reboot required when not using supergfxd
+- Add env var for logging levels to daemon and gui (`RUST_LOG=<error|warn|info|debug|trace>`)
+- ROGCC: Very basic support for running a command on AC/Battery switching, this is in config at `~/.config/rog/rog-control-center.cfg`, and for now must be edited by hand and ROGCC restarted (run ROGCC in BG to use effectively)
+  + Run ROGCC from terminal to see errors of the AC/Battery command
+  + Support for editing via ROGCC GUI will come in future
+  + This is ideal for userspace tasks
+- asusd: Very basic support for running a command on AC/Battery switching, this is in config at `/etc/asusd/asusd.conf`. A restart of asusd is not required if edited.
+  + This is ideal for tasks that require root access (BE SAFE!)
+- The above AC/Battery commands are probably best set to run a script for more complex tasks
+- asusd: check if nvidia-powerd enabled before toggling
+
+## [v4.5.5]
+### Changed
+- remove an unwrap() causing panic on main ROGCC thread
+
+## [v4.5.4]
+### Changed
+- ROGCC:: Allow ROGCC to run without supergfxd
+- ROGCC: Tray/notifs now reads dGPU status directly via supergfx crate (supergfxd not required)
+- Add rust-toolchain to force minimum rust version
+
+## [v4.5.3]
+### Changed
+- Adjust how fan graph in ROGCC works, deny incorrect graphs
+- Fix to apply the fan curve change in ROGCC to the correct profile
+- Support for G713RS LED modes (Author: Peter Ivanov)
+- Support for G713RM LED modes (Author: maxbachmann)
+- Fix VivoBook detection
+- Update dependencies to get latest winit crate (fixes various small issues)
+
+## [v4.5.2]
+### Changed
+- Update dependencies and bump version
+
+## [v4.5.1]
+### Added
+- Support for FA506IE LED modes (Author: Herohtar)
+### Changed
+- Add a basic system tray with dGPU status and gpu mode switch actions
+- Fixup some notifications in ROGCC
+- Add config options for notifications for ROGCC
+- Share states with tray process in ROGCC
+- Share tates with tray process in ROGCC
+
+## [v4.5.0]
+### Added
+- intofy watches on:
+  - `charge_control_end_threshold`
+  - `panel_od`
+  - `gpu_mux_mode`
+  - `platform_profile`
+  - keyboard brightness
+  - These allow for updating any associated config and sending dbus notifications.
+- New dbus methods
+  - `DgpuDisable`
+  - `SetDgpuDisable`
+  - `NotifyDgpuDisable`
+  - `EgpuEnable`
+  - `SetEgpuEnable`
+  - `NotifyEgpuEnable`
+  - `MainsOnline` (This is AC, check if plugged in or not)
+  - `NotifyMainsOnline`
+- `nvidia-powerd.service` will now enable or disable depending on the AC power state
+  and on resume/boot (hybrid boot). It has been proven that this nvidia daemon can be
+  problematic when on battery, not allowing the dgpu to suspend within decent time and
+  sometimes blocking it completely.
+- Notification to rog-control-center of dGPU state change
+### Changed
+- Use loops to ensure that mutex is gained for LED changes.
+- asusctl now uses tokio for async runtime. This helps simplify some code.
+- Properly fix notifs used in rog-control-center
+### Breaking
+- DBUS: all charge control methods renamed to:
+  - `ChargeControlEndThreshold`
+  - `SetChargeControlEndThreshold`
+  - `NotifyChargeControlEndThreshold`
+- DBUS: all panel overdrive methods renamed to:
+  - `PanelOd` (from PanelOverdrive)
+  - `SetPanelOd`
+  - `NotifyPanelOd`
+  - Path `/org/asuslinux/Charge` changed to `/org/asuslinux/Power`
+
+## [v4.4.0] - 2022-08-29
+### Added
+- Support for per-key config has been added to `asusd-user`. At the moment it is
+  basic with only a few effects done. Please see the manual for more information.
+- Support for unzoned and  per-zone effects on some laptops. As above.
+- Added three effects to use with Zoned or Per-Key:
+  + Static, Breathe, Flicker. More to come.
+- Support for G713RS LED modes
+- Support for TUF laptop RGB (kernel patches required, these are submitted upstream)
+### Changed
+- Create new rog-platform crate to manage all i/o in a universal way
+  + kbd-led handling (requires kernel patches, TUF specific)
+  + platform handling (asus-nb-wmi)
+  + power (basic, can be extended in future)
+  + hidraw
+  + usbraw
+- Refactor how ROGCC handles IPC for background open, run-in-bg
+- Refactor daemon task creation to be simpler (for development)
+- Rename dpu_only to gpu_mux. Update all related messages and info.
+### Breaking
+- DBUS: rename path `/org/asuslinux/RogBios` to `/org/asuslinux/Platform`
+- DBUS: renamed `dedicated_graphic_mode` to `gpu_mux_mode` (`GpuMuxMode`)
+- DBUS: renamed `set_dedicated_graphic_mode` to `set_gpu_mux_mode` (`SetGpuMuxMode`)
+  + The methods above take an enum: 0 = Discrete, 1 = Optimus
+
+## [4.3.4] - 2022-08-03
+### Bugfix
+- ROGCC: Remove power setting from correct array
+
+## [4.3.3] - 2022-08-02
+### Added
+- `rog-control-center` has now been moved in to the main workspace due to
+  the heavy dependencies on most of the rog crates
+- Preliminary support of TUF RGB keyboards + power states
+- Support for G713RW LED modes (Author: jarvis2709)
+- Support for G713IC LED modes
+### Changed
+- The udev rules have been changed to make asusd load with all gamer variants when asus-nb-wmi is loaded
+  - TUF, ROG, Zephyrus, Strix
+
+## [4.3.0] - 2022-07-21
+### Added
+- Clear command for anime `asusctl anime --clear` will clear the display
+- Re-added support for LED power states on `0x1866` type keyboards
+### Changed
+- Make rog-anime more error tolerent. Remove various asserts and return errors instead
+- Return error if a pixel-gif is larger than the anime-display dimensions
+- Both Anime and Aura dbus interfaces are changed a little
+  - Aura power has changed, all power related settings are now in one method
+  - Anime methods will now return an error (if errored)
+  - /org/asuslinux/Led renamed to /org/asuslinux/Aura
+
+## [4.2.1] - 2022-07-18
+### Added
+- Add panel overdrive support (autodetects if supported)
+- Add detection of dgpu_disable and egpu_enable for diagnostic
+### Changed
+- Fixed save and restore of multizone LED settings
+- Create defaults for multizone
+
+## [4.2.0] - 2022-07-16
+### Added
+- Support for GA402 Anime Matrix display (Author: I-Al-Istannen & Luke Jones)
+- Support for power-config of all LED zones. See `asusctrl led-power --help` (Author: Luke Jones, With much help from: @MNS26)
+- Full support for multizone LED <logo, keyboard, lightbar> (Author: Luke Jones, With much help from: @MNS26)
+- Add ability to load extra data from `/etc/asusd/asusd-user-ledmodes.toml` for LED support if file exits
+- Support for G513IM LED modes
+- Support for GX703HS LED modes
+### Changed
+- Dbus interface for Aura config has been changed, all power control is done with `SetLedsEnabled` and `SetLedsDisabled`
+- Data for anime-matrix now requires passing the laptop model as enum
+- Extra unit tests for anime stuff to help verify things
+
+### Added
+- Support for GA503R LED modes
+### Changed
+- Refactor LED and AniMe tasks
+- Reload keyboard brightness on resume from sleep/hiber
+
+## [4.1.1] - 2022-06-21
+### Changed
+- Fixes to anime matrix system thread cancelation
+
+## [4.1.0] - 2022-06-20
+### Changed
+- Huge refactor to use zbus 2.2 + zvariant 3.0 in system-daemon.
+- Daemons with tasks now use `smol` for async ops.
+- Fixes to fan-curve settings from CLI (Author: Armas Span)
+- Add brightness to anime zbus notification
+- Adjust how threads in AniMe matrix controller work
+- Use proper power-state packet for keyboard LED's (Author: Martin Piffault)
+### Added
+- Support for GA402R LED modes
+- Support for GU502LV LED modes
+- Support for G512 LED modes
+- Support for G513IC LED modes (Author: dada513)
+- Support for G513QM LED modes (Author: Martin Piffault)
+- Add side-LED toggle support (Author: Martin Piffault)
+- Support reloading keyboard mode on wake (from sleep/hiber)
+- Support reloading charge-level on wake (from sleep/hiber)
+- Support running AniMe animation blocks on wake/sleep and boot/shutdown events
+
+# [4.0.7] - 2021-12-19
+### Changed
+- Fix incorrect power-profile validation
+- Update asusd-ledmodes.toml to support Asus Rog Strix G15 G513QE (@LordVicky)
+- Update patch notes and links
+
+# [4.0.6] - 2021-11-01
+### Changed
+- Fix CLI for bios toggles
+### Added
+- Extra commands for AniMe: pixel-image, gif, pixel-gif
+
+# [4.0.5] - 2021-10-27
+### Changed
+- Convert fan curve percentage to 0-255 expected by kernel driver only if '%' char is used, otherwise the expected range for fan power is 0-255
+- Use correct error in daemon for invalid charging limit
+- Enforce charging limit values in range 20-100
+### Added
+- LED modes for G513QR
+
+# [4.0.4] - 2021-10-02
+### Changed
+- Add missing Profile commands
+- Spawn tasks on individual threads to prevent blocking
+- Don't force fan-curve default on reload
+- Begin obsoleting the graphics switch command in favour of supergfxctl
+- Slim down the notification daemon to pure ASUS notifications
+
+# [4.0.3] - 2021-09-16
+### Changed
+- Don't show fan-curve warning if fan-curve available
+- Add G713QR to Strix led-modes
+- Fix part of CLI fan-curve control
+
+# [4.0.2] - 2021-09-14
+### Changed
+- Backup old configs to *-old if parse fails
+- Prevent some types of crashes related to unpatched kernels
+- Add better help for graphics errors
+- Add better help for asusctl general errors
+- Implement fan-curve dbus API
+- Implement partial fan-curve control via CLI tool
+  + Set fan curve for profile + fan gpu/cpu
+
+# [4.0.1] - 2021-09-11
+### Changed
+- Fix asusd-ledmodes.toml
+
+# [4.0.0] - 2021-09-10
+### Added
+- AniMe:
+  + Support 8bit RGB, RGBA, 16bit Greyscalw, RGB, RGBA
+  + add `AsusImage` type for slanted-template pixel-perfect images
+  + `BREAKING:` plain `Image` with time period is changed and old anime configs break as a result (sorry)
+- LED:
+  + By popular request LED prev/next cycle is added
+  + Add led modes for GX551Q
+### BREAKING CHANGES
+- Graphics control:
+  + graphics control is pulled out of asusd and moved to new package; https://gitlab.com/asus-linux/supergfxctl
+- Proflies:
+  + profiles now depend on power-profile-daemon plus kernel patches for support of platform_profile
+    - if your system supports fan-curves you will also require upcoming kernel patches for this
+  + profiles are now moved to a new file
+  + fan-curves are only partially completed due to this release needing to be done sooner
+
+# [3.7.2] - 2021-08-02
+### Added
+- Enable multizone support on Strix 513IH
+- Add G513QY ledmodes
+### Changed
+- Fix missing CLI command help for some supported options
+- Fix incorrectly selecting profile by name, where the active profile was being copied to the selected profile
+- Add `asusd` version back to `asusctl -v` report
+- Fix various clippy warnings
+
+# [3.7.1] - 2021-06-11
+### Changed
+- Refine graphics mode switching:
+  + Disallow switching to compute or vfio mode unless existing mode is "Integrated"
+
+# [3.7.0] - 2021-06-06
+### Changed
+- Set PM to auto for Nvidia always
+- Extra info output for gfx dev scan
+- Extra info in log for G-Sync to help prevent user confusion around gfx switching
+- Add GA503Q led modes
+- Added ability to fade in/out gifs and images for anime. This does break anime configs. See manual for details.
+- Added task to CtrlLed to set the keyboard LED brightness on wake from suspend
+  + requires a kernel patch which will be upstreamed and in fedora rog kernel
+- Make gfx change from nvidia to vfio/compute also force-change to integrated _then_
+  to requested mode
+- Fix invalid gfx status when switching from some modes
+- Fix copy over of serde skipped config values on config reload
+
+# [3.6.1] - 2021-05-25
+### Changed
+- Bugfix: write correct fan modes for profiles
+- Bugfix: apply created profiles
+
+# [3.6.1] - 2021-05-25
+### Changed
+- Bugfix for cycling through profiles
+
+# [3.6.0] - 2021-05-24
+### Changed
+- Add GX550L led modes
+- Don't save compute/vfio modes. Option in config for this is removed.
+- Store a temporary non-serialised option in config for if compute/vfio is active
+  for informational purposes only (will not apply on boot)
+- Save state for LEDs enabled + sleep animation enabled
+- Save state for AnimMe enabled + boot animation enabled
+- Add extra config options and dbus methods
+- Add power state signals for anime and led
+- Refactor to use channels for dbus signal handler send/recv
+- Split out profiles independant parts to a rog-profiles crate
+- Cleanup dependencies
+- Fix some dbus Supported issues
+
+# [3.5.2] - 2021-05-15
+### Changed
+- Bugfix: prevent the hang on compute/integrated mode change
+
+# [3.5.1] - 2021-04-25
+### Changed
++ Anime:
+  - Fix using multiple configs
+
+# [3.5.0] - 2021-04-25
+### Changed
++ Keyboard:
+  - Split out all aura functionality that isn't dependent on the daemon in to a
+    new crate `rog-aura` (incomplete)
+  - Keyboard LED control now includes:
+    + Enable/disable LED's while laptop is awake
+    + Enable/disable LED animation while laptop is suspended and AC plugged in
+  - Properly reload the last used keyboard mode on boot
++ Graphics:
+  - Correctly enable compute mode for nvidia plus no-reboot or logout if switching
+    from vfio/integrated/compute.
+  - Add asusd config option to not save compute/vfio mode switch.
++ Anime:
+  - Enable basic multiple user anime configs (asusd-user must still be restarted)
++ Profiles:
+  - Enable dbus methods for freq min/max, fan curve, fan preset, CPU turbo enable.
+    These options will apply to the active profile if no profile name is specified.
+
+# [3.4.1] - 2021-04-11
+### Changed
+- Fix anime init sequence
+
+# [3.4.0] - 2021-04-11
+### Changed
+- Revert zbus to 1.9.1
+- Use enum to show power states, and catch missing pci path for nvidia.
+- Partial user-daemon for anime/per-key done, `asusd-user`. Includes asusd-user systemd unit.
+- user-daemon provides dbus emthods to insert anime actions, remove from index, set leds on/off
+  + Config file is stored in `~/.config/rog/rog-user.cfg`
+- AniMe display parts split out to individual crate in preparation for publishing
+  on crates.io
+
+# [3.3.0] - 2021-04-3
+### Changed
+- Add ledmodes for G733QS
+- Add ledmodes for GA401Q
+- Default to vfio disabled in configuration. Will now hard-error if enabled and
+  the kernel modules are builtin. To enable vfio switching `"gfx_vfio_enable": false,`
+  must be changed to `true` in `/etc/asusd/asusd.conf`
+
+# [3.2.4] - 2021-03-24
+### Changed
+- Ignore vfio-builtin error if switching to integrated
+
+# [3.2.3] - 2021-03-24
+### Changed
+- Better handling of session tracking
+### Added
+- List all profile data
+- Get active profile name
+- Get active profile data
+
+# [3.2.2] - 2021-03-23
+### Changed
+- Fix brightness control, again, for non-RGB keyboards
+
+# [3.2.1] - 2021-03-21
+### Changed
+- Fix brightness control
+- Large cleanup of code relating to LED controls
+
+# [3.2.0] - 2021-03-21
+### Changed
+- Refactor keyboard LED handling
+- Added --list for profiles (Thanks @aqez)
+- Added --remove for profiles (Thanks @aqez)
+- Added a graphics mode: vfio. This attaches Nvidia devices to vfio module.
+### Broken
+- Per-key LED modes, which need thinking about how to go ahead with for future
+
+# [3.1.7] - 2021-03-11
+### Changed
+- Refactor many parts of daemon
+- Switch out session monitoring to logind-zbus
+
+# [3.1.6] - 2021-03-11
+### Changed
+- Graphics switching will now wait until all users logged out before switching
+
+### Changed
+- Further tweaks to gfx switching
+- More logging on gfx switching
+- Filter bios help according to supported modes
+- Prevent gfx mode switching if in dedicated/G-Sync mode
+
+# [3.1.4] - 2021-03-10
+### Changed
+- Notify through dbus if user changes profile manually
+- Better help on CLI, show help only for supported items
+- Bugfix to gfx switcher
+
+# [3.1.3] - 2021-03-10
+### Changed
+- Hotfix: gracefully handle removing modules in use caused by display-manager not
+  fully shutdown at the time of trying to remove modules. It will now retry every
+  250ms per module
+
+# [3.1.2] - 2021-03-10
+### Changed
+- Test and create /etc/X11/xorg.conf.d/ if it doesn't exist
+- Hotfix to better report module issues
+
+# [3.1.1] - 2021-03-10
+### Changed
+- Add missing nvidia module nvidia_uvm to gfx ctrl list
+
+# [3.1.0] - 2021-03-09
+### Added
+- GU502LU led-modes
+### Changed
+- Graphics switching is now rebootless, the daemon will now restart the
+  display-manager to switch modes instead. Caveats are:
+  + There is no confirmation from the daemon, the program issuing the command
+    must confirm the request.
+  + systemd only
+- Laptops with dedicated Nvidia mode:
+  + You still must reboot for the bios to switch modes
+  + On boot if dedicated mode is active then asusd will update the required configs
+    to put display-manager in nvidia mode
+
+# [3.0.0] - 2021-02-22
+### Added
+- G531GD led modes
+
+# [3.0.0] - 2021-02-14
+### Changed
+- Write set+apply after each array in multizone
+- Remove misc bad logic
+- Use same code path as 0x1866 device to configure led support for 0x1854 device
+- Remove duplicate code
+- Set correct speeds for multizone
+- Remove dbus crate in favour of zbus. This removes the external dbus lib requirement.
+- Huge internal refactor
+- BREAKING CHANGE: Anime code refactor. DBUS method names have changed
+- Cleanup fan and cpu control + configs
+
+# [2.2.2] - 2021-01-31
+### Changed
+- Fix for dedicated gfx capable laptops in integrated mode
+- Fix for 0x1854 device
+
+# [2.2.1] - 2021-01-27
+### Added
+- Add ROG Zephyrus M15 LED config
+### Changed
+- Bugfixes
+- Fix reboot/restartx status for GFX switching
+- Update readme
+- Change CLI arg tag for fan modes
+- Make dracut include the nvidia modules in initramfs
+
+# [2.2.0] - 2021-01-26
+### Added
+- Dbus command to fetch all supported functions of the laptop. That is, all the
+  functions that asusd supports for the currently running laptop.
+- Bios setting toggles for:
+  + Dedicated gfx toggle (support depends on the laptop)
+  + Bios boot POST sound toggle
+### Changed
+- added config option for dedicated gfx mode on laptops with it to enable
+  switching directly to dedicated using `asusctl graphics -m nvidia`
+
+# [2.1.2] - 2021-01-10
+### Changed
+- Adjust gfx controller to assume that the graphics driver is loaded if the
+  mode is set for nvidia/hybrid
+
+# [2.1.1] - 2021-01-09
+### Changed
+- Updates to dependencies
+
+# [2.1.0] - 2020-10-25
+### Added
+- Option to turn off AniMe display (@asere)
+### Changed
+- Change option -k to show current LED bright (@asere)
+- Correctly disable GFX control via config
+- Panic and exit if config can't be parsed
+- Add DBUS method to toggle to next fan/thermal profile
+- Add DBUS method to toggle to next/prev Aura mode
+
+# [2.0.5] - 2020-09-29
+### Changed
+- Bugfixes
+
+# [2.0.4] - 2020-09-24
+### Changed
+- Better and more verbose error handling and logging in many places.
+- Fix timeout for client waiting on reply for graphics switching
+
+# [2.0.2] - 2020-09-21
+### Changed
+- graphics options via CLI are now a command block:
+  + `asusctl graphics`
+  + -m Mode <nvidia, hybrid, compute, integrated>
+  + -g Get current mode
+  + -f Force reboot or restart display manager without confirmation
 
 # [2.0.0] - 2020-09-21
 ### Changed
@@ -48,6 +633,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fix small deadlock with awaits
 
-## [1.0.0] - 2020-08-13
-
-- Major fork and refactor to use asus-hid patch for ASUS N-Key device
+## [1.0.0]

Cargo.toml

@@ -1,16 +1,61 @@
 [workspace]
-members = ["asus-notify", "asus-nb-ctrl", "asus-nb", "ctrl-gfx"]
+members = ["asusctl", "config-traits", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+
+[workspace.package]
+version = "4.6.2"
+
+[workspace.dependencies]
+async-trait = "^0.1"
+tokio = { version = "^1.23.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^1.3"
+
+zbus = "^3.6"
+logind-zbus = { version = "^3.1.0" } #, default-features = false, features = ["non_blocking"] }
+
+serde = "^1.0"
+serde_derive = "^1.0"
+serde_json = "^1.0"
+toml = "^0.5.10"
+ron = "*"
+
+log = "^0.4"
+env_logger = "^0.10.0"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = "^0.7"
+rusb = "^0.9"
+sysfs-class = "^0.1.3"
+inotify = "^0.10.0"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.4.0"
+gif = "^0.12.0"
+
+versions = "4.1"
+
+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]
 debug = false
 opt-level = 3
+
+[workspace.dependencies.cargo-husky]
+version = "1"
+default-features = false
+features = ["user-hooks"]

Cranky.toml

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

MANUAL.md

@@ -0,0 +1,439 @@
+# asusctrl manual
+
+`asusd` is a utility for Linux to control many aspects of various ASUS laptops
+but can also be used with non-asus laptops with reduced features.
+
+## Programs Available
+
+- `asusd`: The main system daemon. It is autostarted by a udev rule and systemd unit.
+- `asusd-user`: The user level daemon. Currently will run an anime sequence, with RGB keyboard sequences soon.
+- `asusctl`: The CLI for interacting with the system daemon
+- `asus-notify`: A notification daemon with a user systemd unit that can be enabled.
+
+## `asusd`
+
+`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a *safe* dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
+
+The functionality that `asusd` exposes is:
+
+- anime control
+- led keyboard control (aura)
+- charge limiting
+- bios/efivar control
+- power profile switching
+- fan curves (if supported, this is auto-detected)
+
+each of these will be detailed in sections.
+
+### AniMe control
+
+Controller for the fancy AniMe matrix display on the lid of some machines. This controller is a work in progress.
+
+#### Config options
+
+If you have an AniMe device a few system-level config options are enabled for you in `/etc/asusd/anime.conf`;
+
+1. `"system": [],`: currently unused, is intended to be a default continuous sequence in future versions
+2. `"boot": [],`: a sequence that plays on system boot (when asusd is loaded)
+3. `"wake": [],`: a sequence that plays when waking from suspend
+4. `"shutdown": [],`: a sequence that plays when shutdown begins
+5. `"brightness": <FLOAT>`: global brightness control, where `<FLOAT> is 0.0-1.0
+
+Some default examples are provided but are minimal. The full range of configuration options will be covered in another section of this manual.
+
+### Led keyboard control
+
+The LED controller (e.g, aura) enables setting many of the factory modes available if a laptop supports them. It also enables per-key RGB settings but this is a WIP and will likely be similar to how AniMe sequences can be created.
+
+#### Supported laptops
+
+There are over 60 supported laptops as of 01-01-2023. Please see [the rog-aura crate readme for further details](/rog-aura/README.md).
+
+### Charge control
+
+Almost all modern ASUS laptops have charging limit control now. This can be controlled in `/etc/asusd/asusd.conf`.
+
+```json
+"bat_charge_limit": 80,
+```
+where the number is a percentage.
+
+### Bios control
+
+Some options that you find in Armory Crate are available under this controller, so far there is:
+
+- POST sound: this is the sound you hear on bios boot post
+- GPU MUX: this controls if the dGPU is the *only* GPU, making it the main GPU and disabling the iGPU
+
+These options are not written to the config file as they are stored in efivars. The only way to change these is to use the exposed safe dbus methods, or use the `asusctl` CLI tool.
+
+### Profiles
+
+asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.10.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is merged to 5.15 kernel upstream.
+
+A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n` to cycle through the 3 profiles:
+1. Balanced
+2. Performance
+3. Quiet
+
+#### Fan curves
+
+Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/10/23/250) which is accepted for the 5.17 kernel release .
+
+The fan curve format can be of varying formats:
+
+- `30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"`
+- `30:0,40:5,50:10,60:20,70:35,80:55,90:65,100:65"`
+- `30 0,40 5,50 10,60 20,70 35,80 55,90 65,100 65"`
+- `30 0 40 5 50 10 60 20 70 35 80 55 90 65 100 65"`
+
+the order must always be the same "temperature:percentage", lowest from left to rigth being highest.
+
+The config file is located at `/etc/asusd/profile.conf` and is self-descriptive. On first run it is populated with the system EC defaults.
+
+### Support controller
+
+There is one more controller; the support controller. The sole pupose of this controller is to querie all the other controllers for information about their support level for the host laptop. Returns a json string.
+
+## asusd-user
+
+`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the *base* system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
+
+As of now only AniMe is active in this with configuration in `~/.config/rog/`. On first run defaults are created that are intended to work as examples.
+
+The main config is `~/.config/rog/rog-user.cfg`
+
+#### Config options: Aura, per-key and zoned
+
+I'm unsure of how many laptops this works on, so please try it.
+
+`led_type: Key` works only on actual per-key RGB keyboards.
+
+`led_type: Zone` works on zoned laptops.
+
+`led_type: Zone` set to `None` works on zoned ROG laptops, unzoned ROG laptops, and TUF laptops (and yes this does mean an audio EQ can be done now).
+
+`~/.config/rog/rog-user.cfg` contains a setting `"active_aura": "<FILENAME>"` where `<FILENAME>` is the name of the Aura config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "aura-default"`
+
+An Aura config itself is a file with contents:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            Breathe((
+                led: W,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: A,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: S,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: D,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: F,
+                start_colour1: (255, 0, 0),
+                start_colour2: (255, 0, 0),
+                speed: High,
+            )),
+            Static((
+                led: RCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: LCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: Esc,
+                colour: (0, 0, 255),
+            )),
+            DoomFlicker((
+                led: N9,
+                start_colour: (0, 0, 255),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: false,
+    ),
+)
+```
+
+If your laptop supports multizone, `"led"` can also be `"Zone": <one of the following>`
+- `SingleZone` // Keyboards with only one zone
+- `ZonedKbLeft` // keyboard left
+- `ZonedKbLeftMid` // keyboard left-middle
+- `ZonedKbRightMid` // etc
+- `ZonedKbRight`
+- `LightbarRight`
+- `LightbarRightCorner`
+- `LightbarRightBottom`
+- `LightbarLeftBottom`
+- `LightbarLeftCorner`
+- `LightbarLeft`
+
+Single zone example:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            DoomFlicker((
+                led: SingleZone,
+                start_colour: (200, 40, 5),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: true,
+    ),
+)
+```
+
+At the moment there are only three effects available as shown in the example. More will come in the future
+but this may take me some time.
+
+#### Config options: AniMe
+
+`~/.config/rog/rog-user.cfg` contains a setting `"active_anime": "<FILENAME>"` where `<FILENAME>` is the name of the AniMe config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "anime-doom"`
+
+An AniMe config itself is a file with contents:
+
+```json
+{
+  "name": "<FILENAME>",
+  "anime": []
+}
+```
+
+`<FILENAME>` is used as a reference internally. `"anime": []` is an array of sequences (WIP).
+
+##### "anime" array options
+
+Each object in the array can be one of:
+
+1. AsusAnimation
+2. ImageAnimation
+3. Image
+4. Pause
+
+##### AsusAnimation
+
+`AsusAnimation` is specifically for running the gif files that Armory Crate comes with. `asusctl` includes all of these in `/usr/share/asusd/anime/asus/`
+```json
+      "AsusAnimation": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### AsusImage
+
+Virtually the same as `AsusAnimation` but for png files, typically created in the same "slanted" style using a template (`diagonal-template.png`) as the ASUS gifs for pixel perfection.
+
+```json
+      "AsusImage": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### ImageAnimation
+
+`ImageAnimation` can play *any* gif of any size.
+
+```json
+      "ImageAnimation": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Image
+
+`Image` currently requires 8bit greyscale png. It will be able to use most in future.
+
+```json
+    {
+      "Image": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Pause
+
+A `Pause` is handy for after an `Image` to hold the `Image` on the AniMe for a period.
+
+```json
+    {
+      "Pause": {
+        "secs": <INT>,
+        "nanos": <INT>
+      }
+    },
+```
+
+##### Options for objects
+
+**<FILE_PATH>**
+
+Must be full path: `"/usr/share/asusd/anime/asus/gaming/Controller.gif"` or `/home/luke/Downloads/random.gif`.
+
+**<FLOAT>**
+
+A number from 0.0-1.0.
+- `brightness`: If it is brightness it is combined with the system daemon global brightness
+- `scale`: 1.0 is the original size with lower number shrinking, larger growing
+- `angle`: Rotation angle in radians
+- `translation`: Shift the image X -/+, and y -/+
+
+**<TIME>**
+
+Time is the length of time to run the gif for:
+```json
+        "time": {
+          "Time": {
+            "secs": 5,
+            "nanos": 0
+          }
+        },
+```
+A cycle is how many gif loops to run:
+```json
+        "time": {
+          "Cycles": 2
+        },
+```
+`Infinite` means that this gif will never end:
+```json
+        "time": "Infinite",
+```
+`Fade` allows an image or gif to fade in and out, and remain at max brightness to n time:
+```json
+        "time": {
+          "Fade": {
+            "fade_in": {
+              "secs": 2,
+              "nanos": 0
+            },
+            "show_for": {
+              "secs": 1,
+              "nanos": 0
+            },
+            "fade_out": {
+              "secs": 2,
+              "nanos": 0
+            }
+          }
+        },
+```
+`show_for` can be `null`, if it is `null` then the `show_for` becomes `gif_time_length - fade_in - fade_out`.
+This is period for which the gif or image will be max brightness (as set).
+
+**<INT>**
+
+A plain non-float integer.
+
+## asusctl
+
+`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. It can be used in any place a terminal app can be used.
+
+This program will query `asusd` for the `Support` level of the laptop and show or hide options according to this support level.
+
+Most commands are self-explanatory.
+
+### CLI Usage and help
+
+Commands are given by:
+
+```
+asusctl <option> <command> <command-options>
+```
+
+Help is available through:
+
+```
+asusctl --help
+asusctl <command> --help
+```
+
+Some commands may have subcommands:
+
+```
+asusctl <command> <subcommand> --help
+```
+
+### Keybinds
+
+To switch to next/previous Aura modes you will need to bind both the aura keys (if available) to one of:
+**Next**
+```
+asusctl led-mode -n
+```
+**Previous**
+```
+asusctl led-mode -p
+```
+
+To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profile -n`.
+
+## User NOTIFICATIONS via dbus
+
+If you have a notifications handler set up, or are using KDE or Gnome then you
+can enable the user service to get basic notifications when something changes.
+
+```
+systemctl --user enable asus-notify.service
+systemctl --user start asus-notify.service
+```
+
+# License & Trademarks
+
+Mozilla Public License 2 (MPL-2.0)
+
+---
+
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
+
+---

Makefile

@@ -1,36 +1,36 @@
-prefix ?= /usr
-sysconfdir ?= /etc
+VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d.\d.\d)"' Cargo.toml | cut -d'"' -f2)
+
+INSTALL = install
+INSTALL_PROGRAM = ${INSTALL} -D -m 0755
+INSTALL_DATA = ${INSTALL} -D -m 0644
+
+prefix = /usr
 exec_prefix = $(prefix)
 bindir = $(exec_prefix)/bin
-libdir = $(exec_prefix)/lib
-includedir = $(prefix)/include
 datarootdir = $(prefix)/share
-datadir = $(datarootdir)
+libdir = $(exec_prefix)/lib
+zshcpl = $(datarootdir)/zsh/site-functions
 
-SRC = Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
+BIN_ROG := rog-control-center
+BIN_C := asusctl
+BIN_D := asusd
+BIN_U := asusd-user
+LEDCFG := aura_support.ron
 
-.PHONY: all clean distclean install uninstall update
-
-BIN_C=asusctl
-BIN_D=asusd
-BIN_N=asus-notify
-LEDCFG=asusd-ledmodes.toml
-X11CFG=90-nvidia-screen-G05.conf
-UDEVRULES=90-nvidia-pm.rules
-VERSION:=$(shell grep -Pm1 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2)
+SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
-	ARGS += "--release"
+	ARGS += --release
 	TARGET = release
 endif
 
 VENDORED ?= 0
 ifeq ($(VENDORED),1)
-	ARGS += "--frozen"
+	ARGS += --frozen
 endif
 
-all: target/release/$(BIN_D)
+all: build
 
 clean:
 	cargo clean
@@ -38,32 +38,65 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install: all
-	install -D -m 0755 "target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
-	install -D -m 0755 "target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
-	install -D -m 0755 "target/release/$(BIN_N)" "$(DESTDIR)$(bindir)/$(BIN_N)"
-	install -D -m 0644 "data/$(UDEVRULES)" "$(DESTDIR)/lib/udev/rules.d/$(UDEVRULES)"
-	install -D -m 0644 "data/$(BIN_D).rules" "$(DESTDIR)/lib/udev/rules.d/99-$(BIN_D).rules"
-	install -D -m 0644 "data/$(LEDCFG)" "$(DESTDIR)$(sysconfdir)/asusd/$(LEDCFG)"
-	install -D -m 0644 "data/$(BIN_D).conf" "$(DESTDIR)$(sysconfdir)/dbus-1/system.d/$(BIN_D).conf"
-	install -D -m 0644 "data/$(X11CFG)" "$(DESTDIR)$(sysconfdir)/X11/xorg.conf.d/$(X11CFG)"
-	install -D -m 0644 "data/$(BIN_D).service" "$(DESTDIR)/lib/systemd/system/$(BIN_D).service"
-	install -D -m 0644 "data/$(BIN_N).service" "$(DESTDIR)/lib/systemd/user/$(BIN_N).service"
-	install -D -m 0644 "data/icons/asus_notif_yellow.png" "$(DESTDIR)/usr/share/icons/hicolor/512x512/apps/asus_notif_yellow.png"
-	install -D -m 0644 "data/icons/asus_notif_green.png" "$(DESTDIR)/usr/share/icons/hicolor/512x512/apps/asus_notif_green.png"
-	install -D -m 0644 "data/icons/asus_notif_red.png" "$(DESTDIR)/usr/share/icons/hicolor/512x512/apps/asus_notif_red.png"
+install-program:
+	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+	$(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-data:
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
+
+	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
+
+	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
+	$(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"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-integrated.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-nvidia.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+
+	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+
+install: install-program install-data
 
 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)/lib/udev/rules.d/$(UDEVRULES)"
-	rm -f "$(DESTDIR)/lib/udev/rules.d/99-$(BIN_D).rules"
-	rm -f "$(DESTDIR)$(sysconfdir)/dbus-1/system.d/$(BIN_D).conf"
-	rm -f "$(DESTDIR)$(sysconfdir)/X11/xorg.conf.d/$(X11CFG)"
-	rm -f "$(DESTDIR)/lib/systemd/system/$(BIN_D).service"
-	rm -r "$(DESTDIR)/lib/systemd/user/$(BIN_N).service"
-	rm -r "$(DESTDIR)/usr/share/icons/hicolor/512x512/apps/asus_notif_*"
+	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)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+	rm -rf "$(DESTDIR)$(datarootdir)/asusd"
+	rm -rf "$(DESTDIR)$(datarootdir)/rog-gui"
 
 update:
 	cargo update
@@ -74,12 +107,18 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
-	tar pcfJ vendor_asus-nb-ctrl_$(VERSION).tar.xz vendor
+	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
 	rm -rf vendor
 
-target/release/$(BIN_D): $(SRC)
+build:
 ifeq ($(VENDORED),1)
 	@echo "version = $(VERSION)"
-	tar pxf vendor_asus-nb-ctrl_$(VERSION).tar.xz
+	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
+	strip -s ./target/release/$(BIN_C)
+	strip -s ./target/release/$(BIN_D)
+	strip -s ./target/release/$(BIN_U)
+	strip -s ./target/release/$(BIN_ROG)
+
+.PHONY: all clean distclean install uninstall update build

README.md

@@ -1,31 +1,37 @@
-# ASUS NB Ctrl
+# `asusctl` for ASUS ROG
 
-**NOTICE:**
+[![](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/)
 
-This program requires the kernel patch [here](https://www.spinics.net/lists/linux-input/msg68977.html) to be applied.
-Alternatively you may use the dkms module for 'hid-asus-rog` from one of the
-repositories [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/).
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel, or v6.1 which has all my work merged upstream.
 
-The patch enables the following in kernel:
+`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.
 
-- All hotkeys (FN+Key combos)
-- Control of keyboard brightness using FN+Key combos (not RGB)
-- FN+F5 (fan) to toggle fan modes
+Now includes a GUI, `rog-control-center`.
 
-You will not get RGB control in kernel (yet), and asusd is still required to
-change modes and RGB settings. The previous version of this program is named
-`rog-core` and takes full control of the interfaces required - if you can't
-apply the kernel patches then `rog-core` is still highly usable.
+## Kernel support
 
-Many other patches for these laptops, AMD and Intel based, are working their way
-in to the kernel.
+**The minimum supported kernel version is 5.17**
 
----
-asusd is a utility for Linux to control many aspects of various ASUS laptops.
+**For TUF laptops, the minimum supported kernel version is 6.1**
+
+## Goals
+
+1. To provide an interface for rootless control of some system functions most users wish to control such as fan speeds, keyboard LEDs, graphics modes.
+2. Enable third-party apps to use the above with dbus methods
+3. To make the above as easy as possible for new users
+4. Respect the users resources: be small, light, and fast
+
+Point 3 means that the list of supported distros is very narrow - fedora is explicitly
+supported. 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.
 
 ## Discord
 
-[Discord server link](https://discord.gg/PVyFzWj)
+[Discord server link](https://discord.gg/4ZKGd7Un5t)
 
 ## SUPPORTED LAPTOPS
 
@@ -37,77 +43,73 @@ 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.
 
 ## Implemented
 
 - [X] System daemon
+- [X] GUI app
 - [X] User notifications daemon
 - [X] Setting/modifying built-in LED modes
 - [X] Per-key LED setting
-- [X] Fancy LED modes (See examples)
+- [X] Fancy LED modes (See examples) (currently being reworked)
 - [X] Saving settings for reload
-- [X] Logging - required for journalctl
 - [X] AniMatrix display on G14 models that include it
 - [X] Set battery charge limit (with kernel supporting this)
-- [X] Fancy fan control on G14 + G15 thanks to @Yarn1
-- [X] Graphics mode switching between iGPU, dGPU, and On-Demand
+- [X] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
+- [X] Toggle bios setting for boot/POST sound
+- [X] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
-## FUNCTIONS
+# GUI
 
-### Graphics switching
+A gui is now in the repo - ROG Control Center. At this time it is still a WIP, but it has almost all features in place already.
 
-A new feature has been added to enable switching graphics modes. This can be disabled
-in the config with `"manage_gfx": false,`. Please be aware it is a work in progress.
+![](/extra/system.png)
+![](/extra/fan-curves.png)
+![](/extra/keyboard.png)
 
-The CLI option for this does not require root until it asks for it, and provides
-instructions.
+# BUILDING
 
-### KEYBOARD BACKLIGHT MODES
+Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
 
-Models GA401, GA502, GU502 support LED brightness change only (no RGB).
+**Ubuntu (unsuported):**
 
-If you model isn't getting the correct led modes, you can edit the file
-`/etc/asusd/asusd-ledmodes.toml`, the LED Mode numbers are as follows:
+    apt install libgtk-3-dev libpango1.0-dev libgdk-pixbuf-2.0-dev libglib2.0-dev cmake libclang-dev libudev-dev libayatana-appindicator3-1
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
+    make
+    sudo make install
 
-```
-0   STATIC
-1   BREATHING
-2   STROBE
-3   RAINBOW
-4   STAR
-5   RAIN
-6   HIGHLIGHT
-7   LASER
-8   RIPPLE
-10  PULSE
-11  COMET
-12  FLASH
-13  MULTISTATIC
-255 PER_KEY
-```
+**popos (unsuported):**
+    
+    sudo apt install cmake libclang-dev libudev-dev libgtk-3-dev libclang-dev libglib2.0-dev libatkmm-1.6-dev libpangomm-1.4-dev librust-gdk-pixbuf-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
+    make
+    sudo make install
+    
 
-use `cat /sys/class/dmi/id/product_name` to get details about your laptop.
+**fedora:**
 
-## Requirements for compiling
+    dnf install cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf2-devel gtk3-devel libappindicator-gtk3
+    make
+    sudo make install
 
-- `rustc` + `cargo` + `make`
-- `libusb-1.0-0-dev`
-- `libdbus-1-dev`
-- `llvm`
-- `libclang-dev`
-- `libudev-dev`
+**openSUSE:**
+
+Works with KDE Plasma (without GTK packages)
+
+    zypper in -t pattern devel_basis
+    zypper in rustup make cmake systemd-devel clang-devel llvm-devel gdk-pixbuf-devel cairo-devel pango-devel freetype-devel gtk3-devel libexpat-devel libayatana-indicator3-7
+    make
+    sudo make install
 
 ## Installing
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
+- Ubuntu = not supported due to packaging woes, but you can build and install on your own.
 
-Packaging and auto-builds are available [here](https://build.opensuse.org/package/show/home:luke_nukem:asus/asus-nb-ctrl)
-
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/)
-
----
-
-Run `make` then `sudo make install` then reboot.
+=======
 
 The default init method is to use the udev rule, this ensures that the service is
 started when the device is initialised and ready.
@@ -124,99 +126,26 @@ You may also need to activate the service for debian install. If running Pop!_OS
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
-## Updating
+# Contributing
 
-If there has been a config file format change your config will be overwritten. This will
-become less of an issue once the feature set is nailed down. Work is happening to enable
-parsing of older configs and transferring settings to new.
+See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
 
-# Usage
-
-**NOTE! Fan mode toggling requires a newer kernel**. I'm unsure when the patches
-required for it got merged - I've tested with the 5.6.6 kernel and above only.
-To see if the fan-mode changed cat either:
-
-- `cat /sys/devices/platform/asus-nb-wmi/throttle_thermal_policy` or
-- `cat /sys/devices/platform/asus-nb-wmi/fan_boost_mode`
-
-The numbers are 0 = Normal/Balanced, 1 = Boost, 2 = Silent.
-
-Running the program as a daemon manually will require root. Standard (non-daemon)
-mode expects to be communicating with the daemon mode over dbus.
-
-Commands are given by:
-
-```
-asusctl <option> <command> <command-options>
-```
-
-Help is available through:
-
-```
-asusctl --help
-asusctl <command> --help
-```
-
-Some commands may have subcommands:
-
-```
-asusctl <command> <subcommand> --help
-```
-
-## Daemon mode
-
-If the daemon service is enabled then on boot the following will be reloaded from save:
-
-- LED brightness
-- Last used built-in mode
-- fan-boost/thermal mode
-- battery charging limit
-
-The daemon also saves the settings per mode as the keyboard does not do this
-itself - this means cycling through modes with the Aura keys will use the
-settings that were used via CLI.
-
-Daemon mode creates a config file at `/etc/asusd/asusd.conf` which you can edit a 
-little of. Most parts will be byte arrays, but you can adjust things like
-`mode_performance`.
-
-## User daemon for notification via dbus
-
-If you have a notifications handler set up, or are using KDE or Gnome then you
-can enable the user service to get basic notifications when something changes.
-
-```
-systemctl --user enable asus-notify.service
-systemctl --user start asus-notify.service
-```
-# Other
-
-## DBUS Input
-
-See [README_DBUS.md](./README_DBUS.md).
-
-## AniMe input
-
-You will want to look at what MeuMeu has done with [https://github.com/Meumeu/ZephyrusBling/](https://github.com/Meumeu/ZephyrusBling/)
+# OTHER
 
 ## Supporting more laptops
 
 Please file a support request.
 
-## Notes:
-
-- If charge limit or fan modes are not working, then you may require a kernel newer than 5.6.10.
-- AniMe device check is performed on start, if your device has one it will be detected.
-- GA14/GA401 and GA15/GA502/GU502, You will need kernel [patches](https://lab.retarded.farm/zappel/asus-rog-zephyrus-g14/-/tree/master/kernel_patches), these are on their way to the kernel upstream.
-
-# License
+# License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)
 
-# Credits
+---
 
-- [flukejones](https://github.com/flukejones/), project maintainer.
-- [tuxuser](https://github.com/tuxuser/)
-- [aspann](https://github.com/aspann)
-- [meumeu](https://github.com/Meumeu)
-- Anyone missed? Please contact me
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
+
+---

README_DBUS.md

@@ -1,109 +0,0 @@
-# DBUS Guide
-
-**WARNING: In progress updates**
-
-Interface name = org.asuslinux.Daemon
-
-Paths:
-- `/org/asuslinux/Gfx`
-  + `SetVendor` (string)
-  + `NotifyVendor` (recv vendor label string)
-- `/org/asuslinux/Led`
-  + `LedMode` (AuraMode as json)
-  + `LedModes` (array[AuraMode] as json)
-  + `SetLedMode` (AuraMode -> json)
-  + `NotifyLed` (recv json data)
-- `/org/asuslinux/Anime`
-  + `SetAnime` (byte array data)
-- `/org/asuslinux/Charge`
-  + `Limit` (u8)
-  + `SetLimit` (u8)
-  + `NotifyCharge` (recv i8)
-- `/org/asuslinux/Profile`
-  + `Profile` (recv current profile data as json string)
-  + `Profiles` (recv profiles data as json string (map))
-  + `SetProfile` (event -> json)
-  + `NotifyProfile` (recv current profile name)
-
-All `Notify*` methods are signals.
-
-### SetLed
-
-This method expects a string of JSON as input. The JSON is of format such:
-
-```
-{
-  "Static": {
-    "colour": [ 255, 0, 0]
-  }
-}
-```
-
-The possible contents of a mode are:
-
-- `"colour": [u8, u8, u8],`
-- `"speed": <String>,` <Low, Med, High>
-- `"direction": <String>,` <Up, Down, Left, Right>
-
-Modes may or may not be available for a specific laptop (TODO: dbus getter for
-supported modes). Modes are:
-
-- `"Static": { "colour": <colour> },`
-- `"Pulse": { "colour": <colour> },`
-- `"Comet": { "colour": <colour> },`
-- `"Flash": { "colour": <colour> },`
-- `"Strobe": { "speed": <speed> },`
-- `"Rain": { "speed": <speed> },`
-- `"Laser": { "colour": <colour>, "speed": <speed> },`
-- `"Ripple": { "colour": <colour>, "speed": <speed> },`
-- `"Highlight": { "colour": <colour>, "speed": <speed> },`
-- `"Rainbow": { "direction": <direction>, "speed": <speed> },`
-- `"Breathe": { "colour": <colour>, "colour2": <colour>, "speed": <speed> },`
-- `"Star": { "colour": <colour>, "colour2": <colour>, "speed": <speed> },`
-- `"MultiStatic": { "colour1": <colour>, "colour2": <colour>, , "colour3": <colour>, "colour4": <colour> },`
-
-Additionally to the above there is `"RGB": [[u8; 64]; 11]` which is for per-key
-setting of LED's but this requires some refactoring to make it easily useable over
-dbus.
-
-Lastly, there is `"LedBrightness": <u8>` which accepts 0-3 for off, low, med, high.
-
-### SetFanMode
-
-Accepts an integer from the following:
-
-- `0`: Normal
-- `1`: Boost mode
-- `2`: Silent mode
-
-## dbus-send examples OUTDATED
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Static": {"colour": [ 80, 0, 40]}}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Star":{"colour":[0,255,255],"colour2":[0,0,0],"speed":"Med"}}'
-```
-
-**Note:** setting colour2 to `[0,0,255]` activates random star colour. Colour2 has no effect on the
-mode otherwise.
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Star":{"colour":[0,255,255],"colour2":[0,0,255],"speed":"Med"}}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"LedBrightness":3}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetFanMode byte:'2'
-```
-
-Monitoring dbus while sending commands via `rog-core` will give you the json structure if you are otherwise unsure, e.g: `dbus-monitor --system |grep -A2 asuslinux`.
-
-## Getting an introspection .xml
-
-```
-dbus-send --system --print-reply --dest=org.asuslinux.Daemon /org/asuslinux/Charge org.freedesktop.DBus.Introspectable.Introspect > xml/asusd-charge.xml
-```

TODO.md

@@ -1,7 +0,0 @@
-# TODO
-
-- There is lots of code duplication. This should be turned in to macros (dbus stuff etc)
-- Add a little more information to profile notifications such as freq min/max, fan curves
-- Finish splitting out controllers to own crates
-- Finish move to zbus in client when zbus has client signal watch
-- Consider a rename again because the project is getting a lot less ASUS centric

asus-nb-ctrl/Cargo.toml

@@ -1,52 +0,0 @@
-[package]
-name = "asus-nb-ctrl"
-version = "2.0.0"
-license = "MPL-2.0"
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2018"
-
-[lib]
-name = "daemon"
-path = "src/lib.rs"
-
-[[bin]]
-name = "asusctl"
-path = "src/main.rs"
-
-[[bin]]
-name = "asusd"
-path = "src/daemon.rs"
-
-[dependencies]
-ctrl-gfx = { path = "../ctrl-gfx" } 
-asus-nb = { path = "../asus-nb" }
-rusb = "^0.6.0"
-udev = "^0.4.0"
-
-# cli and logging
-gumdrop = "^0.8.0"
-log = "^0.4.8"
-env_logger = "^0.7.1"
-
-# async
-zbus = "1.1.1"
-zvariant = "2.2.0"
-#tokio = { version = "^0.2.4", features = ["rt-threaded", "sync"] }
-
-# serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "0.4.6"
-
-# Device control
-sysfs-class = "^0.1.2" # used for backlight control and baord ID
-rog_fan_curve = { version = "0.1.5", features = ["serde"] }
-# cpu power management
-intel-pstate = "^0.2.1"
-
-yansi-term = "^0.1"

asus-nb-ctrl/src/config.rs

@@ -1,166 +0,0 @@
-use asus_nb::aura_modes::AuraModes;
-use log::{error, warn};
-use rog_fan_curve::Curve;
-use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-
-pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-
-#[derive(Default, Deserialize, Serialize)]
-pub struct Config {
-    pub gfx_managed: bool,
-    pub active_profile: String,
-    pub toggle_profiles: Vec<String>,
-    // TODO: remove power_profile
-    pub power_profile: u8,
-    pub bat_charge_limit: u8,
-    pub kbd_led_brightness: u8,
-    pub kbd_backlight_mode: u8,
-    pub kbd_backlight_modes: Vec<AuraModes>,
-    pub power_profiles: BTreeMap<String, Profile>,
-}
-
-impl Config {
-    /// `load` will attempt to read the config, but if it is not found it
-    /// will create a new default config and write that out.
-    pub fn load(mut self, supported_led_modes: &[u8]) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&CONFIG_PATH)
-            .unwrap(); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                self = Config::create_default(&mut file, &supported_led_modes);
-            } else {
-                self = serde_json::from_str(&buf).unwrap_or_else(|_| {
-                    warn!(
-                        "Could not deserialise {}. Overwriting with default",
-                        CONFIG_PATH
-                    );
-                    Config::create_default(&mut file, &supported_led_modes)
-                });
-            }
-        }
-        self
-    }
-
-    fn create_default(file: &mut File, supported_led_modes: &[u8]) -> Self {
-        // create a default config here
-        let mut config = Config::default();
-        config.gfx_managed = true;
-
-        config.bat_charge_limit = 100;
-        config.kbd_backlight_mode = 0;
-        config.kbd_led_brightness = 1;
-
-        for n in supported_led_modes {
-            config.kbd_backlight_modes.push(AuraModes::from(*n))
-        }
-
-        let profile = Profile::default();
-        config.power_profiles.insert("normal".into(), profile);
-
-        let mut profile = Profile::default();
-        profile.fan_preset = 1;
-        config.power_profiles.insert("boost".into(), profile);
-
-        let mut profile = Profile::default();
-        profile.fan_preset = 2;
-        config.power_profiles.insert("silent".into(), profile);
-
-        config.toggle_profiles.push("normal".into());
-        config.toggle_profiles.push("boost".into());
-        config.toggle_profiles.push("silent".into());
-        config.active_profile = "normal".into();
-
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", CONFIG_PATH));
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", CONFIG_PATH);
-            } else {
-                let x: Config = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn read_new() -> Result<Config, Box<dyn std::error::Error>> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
-        let mut buf = String::new();
-        file.read_to_string(&mut buf)?;
-        let x: Config = serde_json::from_str(&buf)?;
-        Ok(x)
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-
-    pub fn set_mode_data(&mut self, mode: AuraModes) {
-        let byte: u8 = (&mode).into();
-        for (index, n) in self.kbd_backlight_modes.iter().enumerate() {
-            if byte == u8::from(n) {
-                // Consume it, OMNOMNOMNOM
-                self.kbd_backlight_modes[index] = mode;
-                break;
-            }
-        }
-    }
-
-    pub fn get_led_mode_data(&self, num: u8) -> Option<&AuraModes> {
-        for mode in &self.kbd_backlight_modes {
-            if u8::from(mode) == num {
-                return Some(mode);
-            }
-        }
-        None
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Profile {
-    pub min_percentage: u8,
-    pub max_percentage: u8,
-    pub turbo: bool,
-    pub fan_preset: u8,
-    pub fan_curve: Option<Curve>,
-}
-
-#[deprecated]
-pub type CPUSettings = Profile;
-
-impl Default for Profile {
-    fn default() -> Self {
-        Profile {
-            min_percentage: 0,
-            max_percentage: 100,
-            turbo: false,
-            fan_preset: 0,
-            fan_curve: None,
-        }
-    }
-}

asus-nb-ctrl/src/ctrl_anime.rs

@@ -1,205 +0,0 @@
-const INIT_STR: &str = "ASUS Tech.Inc.";
-const PACKET_SIZE: usize = 640;
-
-// Only these two packets must be 17 bytes
-const DEV_PAGE: u8 = 0x5e;
-// These bytes are in [1] position of the array
-const WRITE: u8 = 0xc0;
-const INIT: u8 = 0xc2;
-const APPLY: u8 = 0xc3;
-const SET: u8 = 0xc4;
-
-use asus_nb::error::AuraError;
-use log::{error, info, warn};
-use rusb::{Device, DeviceHandle};
-use std::convert::TryInto;
-use std::error::Error;
-use std::time::Duration;
-use zbus::dbus_interface;
-
-#[allow(dead_code)]
-#[derive(Debug)]
-pub enum AnimatrixCommand {
-    Apply,
-    Set,
-    WriteImage(Vec<Vec<u8>>),
-    //ReloadLast,
-}
-
-pub struct CtrlAnimeDisplay {
-    handle: DeviceHandle<rusb::GlobalContext>,
-    initialised: bool,
-}
-
-//AnimatrixWrite
-pub trait Dbus {
-    fn set_anime(&mut self, input: Vec<Vec<u8>>);
-}
-
-impl crate::ZbusAdd for CtrlAnimeDisplay {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Anime".try_into().unwrap(), self)
-            .unwrap();
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl Dbus for CtrlAnimeDisplay {
-    fn set_anime(&mut self, input: Vec<Vec<u8>>) {
-        self.do_command(AnimatrixCommand::WriteImage(input))
-            .unwrap_or_else(|err| warn!("{}", err));
-    }
-}
-
-impl CtrlAnimeDisplay {
-    #[inline]
-    pub fn new() -> Result<CtrlAnimeDisplay, Box<dyn Error>> {
-        // We don't expect this ID to ever change
-        let device = CtrlAnimeDisplay::get_device(0x0b05, 0x193b)?;
-
-        let mut device = device.open()?;
-        device.reset()?;
-
-        device.set_auto_detach_kernel_driver(true).map_err(|err| {
-            error!("Auto-detach kernel driver failed: {}", err);
-            err
-        })?;
-
-        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {}", err);
-            err
-        })?;
-
-        info!("Device has an AniMe Matrix display");
-        Ok(CtrlAnimeDisplay {
-            handle: device,
-            initialised: false,
-        })
-    }
-
-    #[inline]
-    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)
-    }
-
-    pub fn do_command(&mut self, command: AnimatrixCommand) -> Result<(), AuraError> {
-        if !self.initialised {
-            self.do_initialization()?
-        }
-
-        match command {
-            AnimatrixCommand::WriteImage(effect) => self.write_image(effect)?,
-            AnimatrixCommand::Set => self.do_set()?,
-            AnimatrixCommand::Apply => self.do_apply()?,
-            //AnimatrixCommand::ReloadLast => self.reload_last_builtin(&config).await?,
-        }
-        Ok(())
-    }
-
-    /// Should only be used if the bytes you are writing are verified correct
-    #[inline]
-    fn write_bytes(&self, message: &[u8]) -> Result<(), AuraError> {
-        match self.handle.write_control(
-            0x21,  // request_type
-            0x09,  // request
-            0x35e, // value
-            0x00,  // index
-            message,
-            Duration::from_millis(200),
-        ) {
-            Ok(_) => {}
-            Err(err) => match err {
-                rusb::Error::Timeout => {}
-                _ => error!("Failed to write to led interrupt: {}", err),
-            },
-        }
-        Ok(())
-    }
-
-    /// Write an Animatrix image
-    ///
-    /// The expected input here is *two* Vectors, 640 bytes in length. The two vectors
-    /// are each one half of the full image write.
-    ///
-    /// After each write a flush is written, it is assumed that this tells the device to
-    /// go ahead and display the written bytes
-    ///
-    /// # Note:
-    /// The vectors are expected to contain the full sequence of bytes as follows
-    ///
-    /// - Write pane 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
-    /// - Write pane 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
-    ///
-    /// Where led brightness is 0..255, low to high
-    #[inline]
-    fn write_image(&mut self, image: Vec<Vec<u8>>) -> Result<(), AuraError> {
-        for row in image.iter() {
-            self.write_bytes(row)?;
-        }
-        self.do_flush()?;
-        Ok(())
-    }
-
-    #[inline]
-    fn do_initialization(&mut self) -> Result<(), AuraError> {
-        let mut init = [0; PACKET_SIZE];
-        init[0] = DEV_PAGE; // This is the USB page we're using throughout
-        for (idx, byte) in INIT_STR.as_bytes().iter().enumerate() {
-            init[idx + 1] = *byte
-        }
-        self.write_bytes(&init)?;
-
-        // clear the init array and write other init message
-        for ch in init.iter_mut() {
-            *ch = 0;
-        }
-        init[0] = DEV_PAGE; // write it to be sure?
-        init[1] = INIT;
-
-        self.write_bytes(&init)?;
-        self.initialised = true;
-        Ok(())
-    }
-
-    #[inline]
-    fn do_flush(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = WRITE;
-        flush[2] = 0x03;
-
-        self.write_bytes(&flush)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn do_set(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = SET;
-        flush[2] = 0x01;
-        flush[3] = 0x80;
-
-        self.write_bytes(&flush)?;
-        Ok(())
-    }
-
-    #[inline]
-    fn do_apply(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = APPLY;
-        flush[2] = 0x01;
-        flush[3] = 0x80;
-
-        self.write_bytes(&flush)?;
-        Ok(())
-    }
-}

asus-nb-ctrl/src/ctrl_charge.rs

@@ -1,103 +0,0 @@
-use crate::{config::Config, error::RogError};
-//use crate::dbus::DbusEvents;
-use log::{info, warn};
-use std::convert::TryInto;
-use std::fs::OpenOptions;
-use std::io::Write;
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-
-static BAT_CHARGE_PATH: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
-
-pub struct CtrlCharge {
-    path: &'static str,
-    config: Arc<Mutex<Config>>,
-}
-
-trait Dbus {
-    fn set_limit(&mut self, charge: u8);
-    fn limit(&self) -> i8;
-    fn notify_charge(&self, limit: u8) -> zbus::Result<()>;
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl Dbus for CtrlCharge {
-    fn set_limit(&mut self, limit: u8) {
-        if let Ok(mut config) = self.config.try_lock() {
-            self.set(limit, &mut config).unwrap();
-            self.notify_charge(limit).unwrap();
-        }
-    }
-
-    fn limit(&self) -> i8 {
-        if let Ok(config) = self.config.try_lock() {
-            return config.bat_charge_limit as i8;
-        }
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_charge(&self, limit: u8) -> zbus::Result<()>;
-}
-
-impl crate::ZbusAdd for CtrlCharge {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Charge".try_into().unwrap(), self)
-            .unwrap();
-    }
-}
-
-impl crate::Reloadable for CtrlCharge {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.try_lock() {
-            config.read();
-            info!("Reloaded battery charge limit");
-            self.set(config.bat_charge_limit, &mut config)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlCharge {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        let path = CtrlCharge::get_battery_path()?;
-        info!("Device has battery charge threshold control");
-        Ok(CtrlCharge { path, config })
-    }
-
-    fn get_battery_path() -> Result<&'static str, RogError> {
-        if Path::new(BAT_CHARGE_PATH).exists() {
-            Ok(BAT_CHARGE_PATH)
-        } else {
-            Err(RogError::MissingFunction(
-                "Charge control not available".into(),
-            ))
-        }
-    }
-
-    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
-        if limit < 20 || limit > 100 {
-            warn!(
-                "Unable to set battery charge limit, must be between 20-100: requested {}",
-                limit
-            );
-        }
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        file.write_all(limit.to_string().as_bytes())
-            .map_err(|err| RogError::Write(self.path.into(), err))?;
-        info!("Battery charge limit: {}", limit);
-
-        config.read();
-        config.bat_charge_limit = limit;
-        config.write();
-
-        Ok(())
-    }
-}

asus-nb-ctrl/src/ctrl_fan_cpu.rs

@@ -1,381 +0,0 @@
-use crate::config::{Config, Profile};
-use asus_nb::profile::ProfileEvent;
-use log::{info, warn};
-use std::convert::TryInto;
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::str::FromStr;
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-
-static FAN_TYPE_1_PATH: &str = "/sys/devices/platform/asus-nb-wmi/throttle_thermal_policy";
-static FAN_TYPE_2_PATH: &str = "/sys/devices/platform/asus-nb-wmi/fan_boost_mode";
-static AMD_BOOST_PATH: &str = "/sys/devices/system/cpu/cpufreq/boost";
-
-pub struct CtrlFanAndCPU {
-    pub path: &'static str,
-    config: Arc<Mutex<Config>>,
-}
-
-pub struct DbusFanAndCpu {
-    inner: Arc<Mutex<CtrlFanAndCPU>>,
-}
-
-impl DbusFanAndCpu {
-    pub fn new(inner: Arc<Mutex<CtrlFanAndCPU>>) -> Self {
-        Self { inner }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl DbusFanAndCpu {
-    fn set_profile(&self, profile: String) {
-        if let Ok(event) = serde_json::from_str(&profile) {
-            if let Ok(mut ctrl) = self.inner.try_lock() {
-                if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                    cfg.read();
-                    ctrl.handle_profile_event(&event, &mut cfg)
-                        .unwrap_or_else(|err| warn!("{}", err));
-                    self.notify_profile(&cfg.active_profile)
-                        .unwrap_or_else(|_| ());
-                }
-            }
-        }
-    }
-
-    fn profile(&mut self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                    if let Ok(json) = serde_json::to_string(profile) {
-                        return json;
-                    }
-                }
-            }
-        }
-        "Failed".to_string()
-    }
-
-    fn profiles(&mut self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(mut cfg) = ctrl.config.try_lock() {
-                cfg.read();
-                if let Ok(json) = serde_json::to_string(&cfg.power_profiles) {
-                    return json;
-                }
-            }
-        }
-        "Failed".to_string()
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_profile(&self, profile: &str) -> zbus::Result<()>;
-}
-
-impl crate::ZbusAdd for DbusFanAndCpu {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Profile".try_into().unwrap(), self)
-            .unwrap();
-    }
-}
-
-impl crate::Reloadable for CtrlFanAndCPU {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            let mut file = OpenOptions::new()
-                .write(true)
-                .open(self.path)
-                .map_err(|err| RogError::Path(self.path.into(), err))?;
-            file.write_all(format!("{}\n", config.power_profile).as_bytes())
-                .map_err(|err| RogError::Write(self.path.into(), err))?;
-            let profile = config.active_profile.clone();
-            self.set(&profile, &mut config)?;
-            info!(
-                "Reloaded fan mode: {:?}",
-                FanLevel::from(config.power_profile)
-            );
-        }
-        Ok(())
-    }
-}
-
-impl crate::CtrlTask for CtrlFanAndCPU {
-    fn do_task(&mut self) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read(self.path.into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if let Ok(mut config) = self.config.clone().try_lock() {
-                if config.power_profile != num as u8 {
-                    config.read();
-
-                    let mut i = config
-                        .toggle_profiles
-                        .iter()
-                        .position(|x| x == &config.active_profile)
-                        .map(|i| i + 1)
-                        .unwrap_or(0);
-                    if i >= config.toggle_profiles.len() {
-                        i = 0;
-                    }
-
-                    let new_profile = config
-                        .toggle_profiles
-                        .get(i)
-                        .unwrap_or(&config.active_profile)
-                        .clone();
-
-                    self.set(&new_profile, &mut config)?;
-
-                    info!("Profile was changed: {}", &new_profile);
-                }
-            }
-            return Ok(());
-        }
-
-        Err(RogError::DoTask("Fan-level could not be parsed".into()))
-    }
-}
-
-impl CtrlFanAndCPU {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        let path = CtrlFanAndCPU::get_fan_path()?;
-        info!("Device has thermal throttle control");
-        Ok(CtrlFanAndCPU { path, config })
-    }
-
-    fn get_fan_path() -> Result<&'static str, RogError> {
-        if Path::new(FAN_TYPE_1_PATH).exists() {
-            Ok(FAN_TYPE_1_PATH)
-        } else if Path::new(FAN_TYPE_2_PATH).exists() {
-            Ok(FAN_TYPE_2_PATH)
-        } else {
-            Err(RogError::MissingFunction(
-                "Fan mode not available, you may require a v5.8 series kernel or newer".into(),
-            ))
-        }
-    }
-
-    pub(super) fn do_update(&mut self, config: &mut Config) -> Result<(), RogError> {
-        config.read();
-
-        let mut i = config
-            .toggle_profiles
-            .iter()
-            .position(|x| x == &config.active_profile)
-            .map(|i| i + 1)
-            .unwrap_or(0);
-        if i >= config.toggle_profiles.len() {
-            i = 0;
-        }
-
-        let new_profile = config
-            .toggle_profiles
-            .get(i)
-            .unwrap_or(&config.active_profile)
-            .clone();
-
-        self.set(&new_profile, config)?;
-
-        info!("Profile was changed: {}", &new_profile);
-        Ok(())
-    }
-
-    pub(super) fn set_fan_mode(&mut self, preset: u8, config: &mut Config) -> Result<(), RogError> {
-        let mode = config.active_profile.clone();
-        let mut fan_ctrl = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        config.read();
-        let mut mode_config = config
-            .power_profiles
-            .get_mut(&mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.clone()))?;
-        config.power_profile = preset;
-        mode_config.fan_preset = preset;
-        config.write();
-        fan_ctrl
-            .write_all(format!("{}\n", preset).as_bytes())
-            .map_err(|err| RogError::Write(self.path.into(), err))?;
-        info!("Fan mode set to: {:?}", FanLevel::from(preset));
-        self.set_pstate_for_fan_mode(&mode, config)?;
-        self.set_fan_curve_for_fan_mode(&mode, config)?;
-        Ok(())
-    }
-
-    fn handle_profile_event(
-        &mut self,
-        event: &ProfileEvent,
-        config: &mut Config,
-    ) -> Result<(), RogError> {
-        match event {
-            ProfileEvent::Toggle => self.do_update(config)?,
-            ProfileEvent::ChangeMode(mode) => {
-                self.set_fan_mode(*mode, config)?;
-            }
-            ProfileEvent::Cli(command) => {
-                let profile_key = match command.profile.as_ref() {
-                    Some(k) => k.clone(),
-                    None => config.active_profile.clone(),
-                };
-
-                let mut profile = if command.create {
-                    config
-                        .power_profiles
-                        .entry(profile_key.clone())
-                        .or_insert_with(Profile::default)
-                } else {
-                    config
-                        .power_profiles
-                        .get_mut(&profile_key)
-                        .ok_or_else(|| RogError::MissingProfile(profile_key.clone()))?
-                };
-
-                if command.turbo.is_some() {
-                    profile.turbo = command.turbo.unwrap();
-                }
-                if let Some(min_perc) = command.min_percentage {
-                    profile.min_percentage = min_perc;
-                }
-                if let Some(max_perc) = command.max_percentage {
-                    profile.max_percentage = max_perc;
-                }
-                if let Some(ref preset) = command.preset {
-                    profile.fan_preset = preset.into();
-                }
-                if let Some(ref curve) = command.curve {
-                    profile.fan_curve = Some(curve.clone());
-                }
-
-                self.set(&profile_key, config)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn set(&mut self, profile: &str, config: &mut Config) -> Result<(), RogError> {
-        let mode_config = config
-            .power_profiles
-            .get(profile)
-            .ok_or_else(|| RogError::MissingProfile(profile.into()))?;
-        let mut fan_ctrl = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| RogError::Path(self.path.into(), err))?;
-        fan_ctrl
-            .write_all(format!("{}\n", mode_config.fan_preset).as_bytes())
-            .map_err(|err| RogError::Write(self.path.into(), err))?;
-        config.power_profile = mode_config.fan_preset;
-
-        self.set_pstate_for_fan_mode(profile, config)?;
-        self.set_fan_curve_for_fan_mode(profile, config)?;
-
-        config.active_profile = profile.into();
-
-        config.write();
-        Ok(())
-    }
-
-    fn set_pstate_for_fan_mode(&self, mode: &str, config: &mut Config) -> Result<(), RogError> {
-        info!("Setting pstate");
-        let mode_config = config
-            .power_profiles
-            .get(mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
-
-        // Set CPU pstate
-        if let Ok(pstate) = intel_pstate::PState::new() {
-            pstate.set_min_perf_pct(mode_config.min_percentage)?;
-            pstate.set_max_perf_pct(mode_config.max_percentage)?;
-            pstate.set_no_turbo(!mode_config.turbo)?;
-            info!(
-                "Intel CPU Power: min: {}%, max: {}%, turbo: {}",
-                mode_config.min_percentage, mode_config.max_percentage, mode_config.turbo
-            );
-        } else {
-            info!("Setting pstate for AMD CPU");
-            // must be AMD CPU
-            let mut file = OpenOptions::new()
-                .write(true)
-                .open(AMD_BOOST_PATH)
-                .map_err(|err| RogError::Path(self.path.into(), err))?;
-
-            let boost = if mode_config.turbo { "1" } else { "0" }; // opposite of Intel
-            file.write_all(boost.as_bytes())
-            .map_err(|err| RogError::Write(AMD_BOOST_PATH.into(), err))?;
-            info!("AMD CPU Turbo: {}", boost);
-        }
-        Ok(())
-    }
-
-    fn set_fan_curve_for_fan_mode(&self, mode: &str, config: &Config) -> Result<(), RogError> {
-        let mode_config = &config
-            .power_profiles
-            .get(mode)
-            .ok_or_else(|| RogError::MissingProfile(mode.into()))?;
-
-        if let Some(ref curve) = mode_config.fan_curve {
-            use rog_fan_curve::{Board, Fan};
-            if let Some(board) = Board::from_board_name() {
-                curve.apply(board, Fan::Cpu)?;
-                curve.apply(board, Fan::Gpu)?;
-            } else {
-                warn!("Fan curve unsupported on this board.")
-            }
-        }
-
-        Ok(())
-    }
-}
-
-use crate::error::RogError;
-
-#[derive(Debug)]
-pub enum FanLevel {
-    Normal,
-    Boost,
-    Silent,
-}
-
-impl FromStr for FanLevel {
-    type Err = RogError;
-
-    fn from_str(s: &str) -> Result<Self, RogError> {
-        match s.to_lowercase().as_str() {
-            "normal" => Ok(FanLevel::Normal),
-            "boost" => Ok(FanLevel::Boost),
-            "silent" => Ok(FanLevel::Silent),
-            _ => Err(RogError::ParseFanLevel),
-        }
-    }
-}
-
-impl From<u8> for FanLevel {
-    fn from(n: u8) -> Self {
-        match n {
-            0 => FanLevel::Normal,
-            1 => FanLevel::Boost,
-            2 => FanLevel::Silent,
-            _ => FanLevel::Normal,
-        }
-    }
-}
-
-impl From<FanLevel> for u8 {
-    fn from(n: FanLevel) -> Self {
-        match n {
-            FanLevel::Normal => 0,
-            FanLevel::Boost => 1,
-            FanLevel::Silent => 2,
-        }
-    }
-}

asus-nb-ctrl/src/ctrl_leds.rs

@@ -1,394 +0,0 @@
-// Only these two packets must be 17 bytes
-static LED_APPLY: [u8; 17] = [0x5d, 0xb4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-static LED_SET: [u8; 17] = [0x5d, 0xb5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-use crate::{config::Config, error::RogError, laptops::HELP_ADDRESS};
-use asus_nb::{aura_brightness_bytes, aura_modes::AuraModes, fancy::KeyColourArray, LED_MSG_LEN};
-use log::{info, warn};
-use std::convert::TryInto;
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::dbus_interface;
-
-pub struct CtrlKbdBacklight {
-    led_node: Option<String>,
-    #[allow(dead_code)]
-    kbd_node: Option<String>,
-    pub bright_node: String,
-    supported_modes: Vec<u8>,
-    flip_effect_write: bool,
-    config: Arc<Mutex<Config>>,
-}
-
-pub struct DbusKbdBacklight {
-    inner: Arc<Mutex<CtrlKbdBacklight>>,
-}
-
-impl DbusKbdBacklight {
-    pub fn new(inner: Arc<Mutex<CtrlKbdBacklight>>) -> Self {
-        Self { inner }
-    }
-}
-
-trait Dbus {
-    fn set_led(&mut self, data: String);
-    fn ledmode(&self) -> String;
-    fn notify_led(&self, data: &str) -> zbus::Result<()>;
-}
-
-impl crate::ZbusAdd for DbusKbdBacklight {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Led".try_into().unwrap(), self)
-            .unwrap();
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl DbusKbdBacklight {
-    fn set_led_mode(&mut self, data: String) {
-        if let Ok(data) = serde_json::from_str(&data) {
-            if let Ok(mut ctrl) = self.inner.try_lock() {
-                if let Ok(mut cfg) = ctrl.config.clone().try_lock() {
-                    match &data {
-                        AuraModes::PerKey(_) => {
-                            ctrl.do_command(data, &mut cfg)
-                                .unwrap_or_else(|err| warn!("{}", err));
-                        }
-                        _ => {
-                            let json = serde_json::to_string(&data).unwrap();
-                            ctrl.do_command(data, &mut cfg)
-                                .unwrap_or_else(|err| warn!("{}", err));
-                            self.notify_led(&json).unwrap();
-                        }
-                    }
-                }
-            }
-        } else {
-            warn!("SetKeyBacklight could not deserialise");
-        }
-    }
-
-    fn led_mode(&self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                if let Some(mode) = cfg.get_led_mode_data(cfg.kbd_backlight_mode) {
-                    if let Ok(json) = serde_json::to_string(&mode) {
-                        return json;
-                    }
-                }
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not deserialise".to_string()
-    }
-
-    fn led_modes(&self) -> String {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            if let Ok(cfg) = ctrl.config.clone().try_lock() {
-                if let Ok(json) = serde_json::to_string(&cfg.kbd_backlight_modes) {
-                    return json;
-                }
-            }
-        }
-        warn!("SetKeyBacklight could not deserialise");
-        "SetKeyBacklight could not deserialise".to_string()
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_led(&self, data: &str) -> zbus::Result<()>;
-}
-
-impl crate::Reloadable for CtrlKbdBacklight {
-    fn reload(&mut self) -> Result<(), RogError> {
-        // set current mode (if any)
-        if let Ok(mut config) = self.config.clone().try_lock() {
-            if self.supported_modes.len() > 1 {
-                if self.supported_modes.contains(&config.kbd_backlight_mode) {
-                    let mode = config
-                        .get_led_mode_data(config.kbd_backlight_mode)
-                        .ok_or(RogError::NotSupported)?
-                        .to_owned();
-                    self.write_mode(&mode)?;
-                    info!("Reloaded last used mode");
-                } else {
-                    warn!(
-                        "An unsupported mode was set: {}, reset to first mode available",
-                        <&str>::from(&<AuraModes>::from(config.kbd_backlight_mode))
-                    );
-                    for (idx, mode) in config.kbd_backlight_modes.iter_mut().enumerate() {
-                        if !self.supported_modes.contains(&mode.into()) {
-                            config.kbd_backlight_modes.remove(idx);
-                            config.write();
-                            break;
-                        }
-                    }
-                    config.kbd_backlight_mode = self.supported_modes[0];
-                    // TODO: do a recursive call with a boxed dyn future later
-                    let mode = config
-                        .get_led_mode_data(config.kbd_backlight_mode)
-                        .ok_or(RogError::NotSupported)?
-                        .to_owned();
-                    self.write_mode(&mode)?;
-                    info!("Reloaded last used mode");
-                }
-            }
-
-            // Reload brightness
-            let bright = config.kbd_led_brightness;
-            let bytes = aura_brightness_bytes(bright);
-            self.write_bytes(&bytes)?;
-            info!("Reloaded last used brightness");
-        }
-        Ok(())
-    }
-}
-
-impl crate::CtrlTask for CtrlKbdBacklight {
-    fn do_task(&mut self) -> Result<(), RogError> {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.bright_node)
-            .map_err(|err| RogError::Path((&self.bright_node).into(), err))?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)
-            .map_err(|err| RogError::Read("buffer".into(), err))?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if let Ok(mut config) = self.config.clone().try_lock() {
-                if config.kbd_led_brightness != num as u8 {
-                    config.read();
-                    config.kbd_led_brightness = num as u8;
-                    config.write();
-                }
-            }
-            return Ok(());
-        }
-        Err(RogError::ParseLED)
-    }
-}
-
-impl CtrlKbdBacklight {
-    #[inline]
-    pub fn new(
-        id_product: &str,
-        condev_iface: Option<&String>,
-        supported_modes: Vec<u8>,
-        config: Arc<Mutex<Config>>,
-    ) -> Self {
-        // TODO: return error if *all* nodes are None
-        CtrlKbdBacklight {
-            led_node: Self::get_node_failover(id_product, None, Self::scan_led_node).ok(),
-            kbd_node: Self::get_node_failover(id_product, condev_iface, Self::scan_kbd_node).ok(),
-            // TODO: Check for existance
-            bright_node: "/sys/class/leds/asus::kbd_backlight/brightness".to_string(),
-            supported_modes,
-            flip_effect_write: false,
-            config,
-        }
-    }
-
-    fn get_node_failover(
-        id_product: &str,
-        iface: Option<&String>,
-        fun: fn(&str, Option<&String>) -> Result<String, RogError>,
-    ) -> Result<String, RogError> {
-        for n in 0..=2 {
-            // 0,1,2 inclusive
-            match fun(id_product, iface) {
-                Ok(o) => return Ok(o),
-                Err(e) => {
-                    if n == 2 {
-                        warn!("Looking for node: {}", e.to_string());
-                        std::thread::sleep(std::time::Duration::from_secs(1));
-                    } else {
-                        break;
-                    }
-                }
-            }
-        }
-        // Shouldn't be possible to reach this...
-        Err(RogError::NotFound(format!("{}, {:?}", id_product, iface)))
-    }
-
-    fn scan_led_node(id_product: &str, _: Option<&String>) -> 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").unwrap() == id_product {
-                    // && device.parent().unwrap().sysnum().unwrap() == 3
-                    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());
-                    }
-                }
-            }
-        }
-        warn!("Did not find a hidraw node for LED control, your device may be unsupported or require a kernel patch, see: {}", HELP_ADDRESS);
-        Err(RogError::MissingFunction(
-            "ASUS LED device node not found".into(),
-        ))
-    }
-
-    fn scan_kbd_node(id_product: &str, iface: Option<&String>) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("input").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-        enumerator
-            .match_property("ID_MODEL_ID", id_product)
-            .map_err(|err| {
-                warn!("{}", err);
-                RogError::Udev("match_property failed".into(), err)
-            })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            err
-        }).map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(dev_node) = device.devnode() {
-                if let Some(inum) = device.property_value("ID_USB_INTERFACE_NUM") {
-                    if let Some(iface) = iface {
-                        if inum == iface.as_str() {
-                            info!("Using device at: {:?} for keyboard polling", dev_node);
-                            return Ok(dev_node.to_string_lossy().to_string());
-                        }
-                    }
-                }
-            }
-        }
-
-        warn!("Did not find keyboard consumer device node, if expected functions are missing please file an issue at {}", HELP_ADDRESS);
-        Err(RogError::MissingFunction(
-            "ASUS keyboard 'Consumer Device' node not found".into(),
-        ))
-    }
-
-    pub fn do_command(&mut self, mode: AuraModes, config: &mut Config) -> Result<(), RogError> {
-        self.set_and_save(mode, config)
-    }
-
-    /// 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) {
-                file.write_all(message).unwrap();
-                return Ok(());
-            }
-        }
-        Err(RogError::NotSupported)
-    }
-
-    /// Write an effect block
-    #[inline]
-    fn write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), RogError> {
-        if self.flip_effect_write {
-            for row in effect.iter().rev() {
-                self.write_bytes(row)?;
-            }
-        } else {
-            for row in effect.iter() {
-                self.write_bytes(row)?;
-            }
-        }
-        self.flip_effect_write = !self.flip_effect_write;
-        Ok(())
-    }
-
-    /// Used to set a builtin mode and save the settings for it
-    ///
-    /// This needs to be universal so that settings applied by dbus stick
-    #[inline]
-    fn set_and_save(&mut self, mode: AuraModes, config: &mut Config) -> Result<(), RogError> {
-        match mode {
-            AuraModes::LedBrightness(n) => {
-                let bytes: [u8; LED_MSG_LEN] = (&mode).into();
-                self.write_bytes(&bytes)?;
-                config.read();
-                config.kbd_led_brightness = n;
-                config.write();
-                info!("LED brightness set to {:#?}", n);
-            }
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes)?;
-                } else {
-                    self.write_effect(&v)?;
-                }
-            }
-            _ => {
-                config.read();
-                let mode_num: u8 = u8::from(&mode);
-                self.write_mode(&mode)?;
-                config.kbd_backlight_mode = mode_num;
-                config.set_mode_data(mode);
-                config.write();
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn write_mode(&mut self, mode: &AuraModes) -> Result<(), RogError> {
-        match mode {
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes)?;
-                } else {
-                    self.write_effect(v)?;
-                }
-            }
-            _ => {
-                let mode_num: u8 = u8::from(mode);
-                match mode {
-                    AuraModes::MultiStatic(_) => {
-                        if self.supported_modes.contains(&mode_num) {
-                            let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
-                            for array in bytes.iter() {
-                                self.write_bytes(array)?;
-                            }
-                        }
-                    }
-                    _ => {
-                        if self.supported_modes.contains(&mode_num) {
-                            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(())
-    }
-}

asus-nb-ctrl/src/daemon.rs

@@ -1,139 +0,0 @@
-use ctrl_gfx::ctrl_gfx::CtrlGraphics;
-use daemon::config::Config;
-use daemon::ctrl_anime::CtrlAnimeDisplay;
-use daemon::ctrl_charge::CtrlCharge;
-use daemon::ctrl_fan_cpu::{CtrlFanAndCPU, DbusFanAndCpu};
-use daemon::ctrl_leds::{CtrlKbdBacklight, DbusKbdBacklight};
-use daemon::laptops::match_laptop;
-
-use asus_nb::DBUS_NAME;
-use daemon::{CtrlTask, Reloadable, ZbusAdd};
-use log::LevelFilter;
-use log::{error, info, warn};
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-use zbus::fdo;
-use zbus::Connection;
-
-pub fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut logger = env_logger::Builder::new();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    info!("Version: {}", daemon::VERSION);
-    start_daemon()?;
-    Ok(())
-}
-
-// Timing is such that:
-// - interrupt write is minimum 1ms (sometimes lower)
-// - read interrupt must timeout, minimum of 1ms
-// - for a single usb packet, 2ms total.
-// - to maintain constant times of 1ms, per-key colours should use
-//   the effect endpoint so that the complete colour block is written
-//   as fast as 1ms per row of the matrix inside it. (10ms total time)
-//
-// DBUS processing takes 6ms if not tokiod
-fn start_daemon() -> Result<(), Box<dyn Error>> {
-    let laptop = match_laptop();
-    let config = if let Some(laptop) = laptop.as_ref() {
-        Config::default().load(laptop.supported_modes())
-    } else {
-        Config::default().load(&[])
-    };
-
-    let connection = Connection::new_system()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut object_server = zbus::ObjectServer::new(&connection);
-
-    let config = Arc::new(Mutex::new(config));
-
-    match CtrlCharge::new(config.clone()) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("charge_control: {}", err);
-        }
-    }
-
-    match CtrlAnimeDisplay::new() {
-        Ok(ctrl) => {
-            ctrl.add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("AniMe control: {}", err);
-        }
-    }
-
-    match CtrlGraphics::new() {
-        Ok(mut ctrl) => {
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Gfx controller: {}", err));
-            ctrl.add_to_server(&mut object_server);
-        }
-        Err(err) => {
-            error!("Gfx control: {}", err);
-        }
-    }
-
-    // Collect tasks for task thread
-    let mut tasks: Vec<Arc<Mutex<dyn CtrlTask + Send>>> = Vec::new();
-
-    match CtrlFanAndCPU::new(config.clone()) {
-        Ok(mut ctrl) => {
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("Profile control: {}", err));
-            let tmp = Arc::new(Mutex::new(ctrl));
-            DbusFanAndCpu::new(tmp.clone()).add_to_server(&mut object_server);
-            tasks.push(tmp);
-        }
-        Err(err) => {
-            error!("Profile control: {}", err);
-        }
-    };
-
-    if let Some(laptop) = laptop {
-        let ctrl = CtrlKbdBacklight::new(
-            laptop.usb_product(),
-            laptop.condev_iface(),
-            laptop.supported_modes().to_owned(),
-            config,
-        );
-        let tmp = Arc::new(Mutex::new(ctrl));
-        DbusKbdBacklight::new(tmp.clone()).add_to_server(&mut object_server);
-        tasks.push(tmp);
-    }
-
-    // TODO: implement messaging between threads to check fails
-    // These tasks generally read a sys path or file to check for a
-    // change
-    let _handle = std::thread::Builder::new()
-        .name("asusd watch".to_string())
-        .spawn(move || loop {
-            std::thread::sleep(std::time::Duration::from_millis(100));
-
-            for ctrl in tasks.iter() {
-                if let Ok(mut lock) = ctrl.try_lock() {
-                    lock.do_task().unwrap();
-                }
-            }
-        });
-
-    loop {
-        if let Err(err) = object_server.try_handle_next() {
-            eprintln!("{}", err);
-        }
-    }
-}

asus-nb-ctrl/src/error.rs

@@ -1,58 +0,0 @@
-use std::fmt;
-use std::convert::From;
-use intel_pstate::PStateError;
-use rog_fan_curve::CurveError;
-
-#[derive(Debug)]
-pub enum RogError {
-    ParseFanLevel,
-    ParseVendor,
-    ParseLED,
-    MissingProfile(String),
-    Udev(String, std::io::Error),
-    Path(String, std::io::Error),
-    Read(String, std::io::Error),
-    Write(String, std::io::Error),
-    NotSupported,
-    NotFound(String),
-    IntelPstate(PStateError),
-    FanCurve(CurveError),
-    DoTask(String),
-    MissingFunction(String),
-}
-
-impl fmt::Display for RogError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            RogError::ParseFanLevel => write!(f, "Parse profile error"),
-            RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
-            RogError::ParseLED => write!(f, "Parse LED error"),
-            RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
-            RogError::Udev(deets, error) => write!(f, "udev {}: {}", deets, error),
-            RogError::Path(path, error) => write!(f, "Path {}: {}", path, error),
-            RogError::Read(path, error) => write!(f, "Read {}: {}", path, error),
-            RogError::Write(path, error) => write!(f, "Write {}: {}", path, error),
-            RogError::NotSupported => write!(f, "Not supported"),
-            RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
-            RogError::IntelPstate(err) => write!(f, "Intel pstate error: {}", err),
-            RogError::FanCurve(err) => write!(f, "Custom fan-curve error: {}", err),
-            RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
-            RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
-        }
-    }
-}
-
-impl std::error::Error for RogError {}
-
-impl From<PStateError> for RogError {
-    fn from(err: PStateError) -> Self {
-        RogError::IntelPstate(err)
-    }
-}
-
-impl From<CurveError> for RogError {
-    fn from(err: CurveError) -> Self {
-        RogError::FanCurve(err)
-    }
-}

asus-nb-ctrl/src/laptops.rs

@@ -1,144 +0,0 @@
-use asus_nb::aura_modes::{AuraModes, BREATHING, STATIC, STROBE};
-use log::{info, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";
-
-pub static HELP_ADDRESS: &str = "https://gitlab.com/asus-linux/asus-nb-ctrl";
-
-pub struct LaptopBase {
-    usb_product: String,
-    condev_iface: Option<String>, // required for finding the Consumer Device interface
-    supported_modes: Vec<u8>,
-}
-
-impl LaptopBase {
-    pub fn usb_product(&self) -> &str {
-        &self.usb_product
-    }
-    pub fn condev_iface(&self) -> Option<&String> {
-        self.condev_iface.as_ref()
-    }
-    pub fn supported_modes(&self) -> &[u8] {
-        &self.supported_modes
-    }
-}
-
-pub fn match_laptop() -> Option<LaptopBase> {
-    for device in rusb::devices().unwrap().iter() {
-        let device_desc = device.device_descriptor().unwrap();
-        if device_desc.vendor_id() == 0x0b05 {
-            match device_desc.product_id() {
-                0x1866 => {
-                    let laptop = select_1866_device("1866".to_owned());
-                    print_modes(&laptop.supported_modes);
-                    return Some(laptop);
-                }
-                0x1869 => return Some(select_1866_device("1869".to_owned())),
-                0x1854 => {
-                    info!("Found GL753 or similar");
-                    return Some(LaptopBase {
-                        usb_product: "1854".to_string(),
-                        condev_iface: None,
-                        supported_modes: vec![STATIC, BREATHING, STROBE],
-                    });
-                }
-                _ => {}
-            }
-        }
-    }
-    warn!(
-        "Unsupported laptop, please request support at {}",
-        HELP_ADDRESS
-    );
-    warn!("Continuing with minimal support");
-    None
-}
-
-fn select_1866_device(prod: String) -> LaptopBase {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-    let prod_name = dmi.product_name().expect("Could not get product_name");
-
-    info!("Product name: {}", prod_name.trim());
-    info!("Board name: {}", board_name.trim());
-
-    let mut laptop = LaptopBase {
-        usb_product: prod,
-        condev_iface: Some("02".to_owned()),
-        supported_modes: vec![],
-    };
-
-    if let Some(modes) = LEDModeGroup::load_from_config() {
-        if let Some(led_modes) = modes.matcher(&prod_family, &board_name) {
-            laptop.supported_modes = led_modes;
-            return laptop;
-        }
-    }
-    laptop
-}
-
-fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModes>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect or missing please request support at {}",
-            HELP_ADDRESS
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModeGroup {
-    led_modes: Vec<LEDModes>,
-}
-
-impl LEDModeGroup {
-    /// Consumes the LEDModes
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<Vec<u8>> {
-        for led_modes in self.led_modes {
-            if prod_family.contains(&led_modes.prod_family) {
-                for board in led_modes.board_names {
-                    if board_name.contains(&board) {
-                        info!("Matched to {} {}", led_modes.prod_family, board);
-                        return Some(led_modes.led_modes);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&LEDMODE_CONFIG_PATH) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", LEDMODE_CONFIG_PATH);
-                } else {
-                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
-                        panic!("Could not deserialise {}", LEDMODE_CONFIG_PATH)
-                    }));
-                }
-            }
-        }
-        warn!("Does {} exist?", LEDMODE_CONFIG_PATH);
-        None
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModes {
-    prod_family: String,
-    board_names: Vec<String>,
-    led_modes: Vec<u8>,
-}

asus-nb-ctrl/src/lib.rs

@@ -1,40 +0,0 @@
-#![deny(unused_must_use)]
-/// Configuration loading, saving
-pub mod config;
-///
-pub mod ctrl_anime;
-///
-pub mod ctrl_charge;
-///
-pub mod ctrl_fan_cpu;
-///
-pub mod ctrl_leds;
-///
-/// Laptop matching to determine capabilities
-pub mod laptops;
-
-mod error;
-
-use config::Config;
-use crate::error::RogError;
-use zbus::ObjectServer;
-
-pub static VERSION: &str = "2.0.0";
-
-pub trait Reloadable {
-    fn reload(&mut self) -> Result<(), RogError>;
-}
-
-pub trait ZbusAdd {
-    fn add_to_server(self, server: &mut ObjectServer);
-}
-
-pub trait CtrlTask {
-    fn do_task(&mut self) -> Result<(), RogError>;
-}
-
-pub trait CtrlTaskComplex {
-    type A;
-
-    fn do_task(&mut self, config: &mut Config, event: Self::A);
-}

asus-nb-ctrl/src/main.rs

@@ -1,133 +0,0 @@
-use asus_nb::{
-    cli_options::{LedBrightness, SetAuraBuiltin},
-    core_dbus::AuraDbusClient,
-    profile::{ProfileCommand, ProfileEvent},
-};
-use ctrl_gfx::vendors::GfxVendors;
-use daemon::ctrl_fan_cpu::FanLevel;
-use gumdrop::Options;
-use log::LevelFilter;
-use std::io::Write;
-use yansi_term::Colour::Green;
-use yansi_term::Colour::Red;
-
-#[derive(Options)]
-struct CLIStart {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(help = "show program version number")]
-    version: bool,
-    #[options(meta = "VAL", help = "<off, low, med, high>")]
-    kbd_bright: Option<LedBrightness>,
-    #[options(meta = "PWR", help = "<silent, normal, boost>")]
-    pwr_profile: Option<FanLevel>,
-    #[options(meta = "CHRG", help = "<20-100>")]
-    chg_limit: Option<u8>,
-    #[options(help = "Set graphics mode: <nvidia, hybrid, compute, integrated>")]
-    graphics: Option<GfxVendors>,
-    #[options(command)]
-    command: Option<Command>,
-}
-
-#[derive(Options)]
-enum Command {
-    #[options(help = "Set the keyboard lighting from built-in modes")]
-    LedMode(LedModeCommand),
-    #[options(help = "Create and configure profiles")]
-    Profile(ProfileCommand),
-}
-
-#[derive(Options)]
-struct LedModeCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(command, required)]
-    command: Option<SetAuraBuiltin>,
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut logger = env_logger::Builder::new();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    let parsed = CLIStart::parse_args_default_or_exit();
-
-    if parsed.version {
-        println!("Version: {}", daemon::VERSION);
-    }
-
-    let writer = AuraDbusClient::new()?;
-
-    match parsed.command {
-        Some(Command::LedMode(mode)) => {
-            if let Some(command) = mode.command {
-                writer.write_builtin_mode(&command.into())?
-            }
-        }
-        Some(Command::Profile(command)) => {
-            writer.write_profile_command(&ProfileEvent::Cli(command))?
-        }
-        None => (),
-    }
-
-    if let Some(brightness) = parsed.kbd_bright {
-        writer.write_brightness(brightness.level())?;
-    }
-    if let Some(fan_level) = parsed.pwr_profile {
-        writer.write_fan_mode(fan_level.into())?;
-    }
-    if let Some(chg_limit) = parsed.chg_limit {
-        writer.write_charge_limit(chg_limit)?;
-    }
-    if let Some(gfx) = parsed.graphics {
-        println!("Updating settings, please wait...");
-        println!("If this takes longer than 30s, ctrl+c then check journalctl");
-
-        writer.write_gfx_mode(gfx)?;
-        let res = writer.wait_gfx_changed()?;
-        match res.as_str() {
-            "reboot" => println!(
-                "{}\n{}",
-                Green.paint("\nGraphics vendor mode changed successfully\n"),
-                Red.paint("\nPlease reboot to complete switch to iGPU\n")
-            ),
-            "restartx" => {
-                println!(
-                    "{}",
-                    Green.paint("\nGraphics vendor mode changed successfully\n")
-                );
-                restart_x()?;
-                std::process::exit(1)
-            }
-            _ => std::process::exit(-1),
-        }
-        std::process::exit(-1)
-    }
-    Ok(())
-}
-
-fn restart_x() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Restart X server? y/n");
-
-    let mut buf = String::new();
-    std::io::stdin().read_line(&mut buf).expect("Input failed");
-    let input = buf.chars().next().unwrap() as char;
-
-    if input == 'Y' || input == 'y' {
-        println!("Restarting X server");
-        let status = std::process::Command::new("systemctl")
-            .arg("restart")
-            .arg("display-manager.service")
-            .status()?;
-
-        if !status.success() {
-            println!("systemctl: display-manager returned with {}", status);
-        }
-    } else {
-        println!("{}", Red.paint("Cancelled. Please restart X when ready"));
-    }
-    Ok(())
-}

asus-nb/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "asus-nb"
-version = "2.0.0"
-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 small library of effect types and conversions for ROG Aura"
-edition = "2018"
-
-[dependencies]
-gumdrop = "^0.8"
-dbus = { version = "^0.8" }
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-yansi-term = "^0.1"
-rog_fan_curve = { version = "0.1", features = ["serde"] }
-zbus = "1.1.1"
-zvariant = "2.2.0"
-ctrl-gfx = { path = "../ctrl-gfx" } 
-
-[dev-dependencies]
-tinybmp = "^0.2.3"

asus-nb/examples/animatrix.rs

@@ -1,41 +0,0 @@
-use asus_nb::anime_dbus::AniMeDbusWriter;
-use asus_nb::anime_matrix::{AniMeMatrix, AniMePacketType, HEIGHT, WIDTH};
-use tinybmp::{Bmp, Pixel};
-
-fn main() {
-    let mut writer = AniMeDbusWriter::new().unwrap();
-
-    let bmp =
-        Bmp::from_slice(include_bytes!("non-skewed_r.bmp")).expect("Failed to parse BMP image");
-    let pixels: Vec<Pixel> = bmp.into_iter().collect();
-    //assert_eq!(pixels.len(), 56 * 56);
-
-    // Try an outline, top and right
-    let mut matrix = AniMeMatrix::new();
-
-    // Aligned left
-    for px in pixels {
-        if (px.x as usize / 2) < WIDTH && (px.y as usize) < HEIGHT && px.x % 2 == 0 {
-            matrix.get_mut()[px.y as usize][px.x as usize / 2] = px.color as u8;
-        }
-    }
-
-    // Throw an alignment border up
-    // {
-    //     let tmp = matrix.get_mut();
-    //     for x in tmp[0].iter_mut() {
-    //         *x = 0xff;
-    //     }
-    //     for row in tmp.iter_mut() {
-    //         row[row.len() - 1] = 0xff;
-    //     }
-    // }
-
-    matrix.debug_print();
-
-    let mut matrix: AniMePacketType = AniMePacketType::from(matrix);
-    // println!("{:?}", matrix[0].to_vec());
-    // println!("{:?}", matrix[1].to_vec());
-
-    writer.write_image(&mut matrix).unwrap();
-}

asus-nb/src/anime_dbus.rs

@@ -1,79 +0,0 @@
-use crate::anime_matrix::AniMePacketType;
-use crate::{DBUS_IFACE, DBUS_NAME};
-use dbus::channel::Sender;
-use dbus::{blocking::Connection, Message};
-use std::error::Error;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-use std::{thread, time::Duration};
-
-pub const ANIME_PANE1_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
-pub const ANIME_PANE2_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
-
-/// Interface for the AniMe dot-matrix display
-///
-/// The resolution is 34x56 (1904) but only 1,215 LEDs in the top-left are used.
-/// The display is available only on select GA401 models.
-///
-/// Actual image ration when displayed is stretched width.
-///
-/// Data structure should be nested array of [[u8; 33]; 56]
-pub struct AniMeDbusWriter {
-    connection: Box<Connection>,
-    block_time: u64,
-    stop: Arc<AtomicBool>,
-}
-
-impl AniMeDbusWriter {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-        Ok(AniMeDbusWriter {
-            connection: Box::new(connection),
-            block_time: 25,
-            stop: Arc::new(AtomicBool::new(false)),
-        })
-    }
-
-    pub fn write_image_to_buf(_buf: &mut AniMePacketType, _image_data: &[u8]) {
-        unimplemented!("Image format is in progress of being worked out")
-    }
-
-    /// Write an Animatrix image
-    ///
-    /// The expected input here is *two* Vectors, 640 bytes in length. The two vectors
-    /// are each one half of the full image write.
-    ///
-    /// After each write a flush is written, it is assumed that this tells the device to
-    /// go ahead and display the written bytes
-    ///
-    /// # Note:
-    /// The vectors are expected to contain the full sequence of bytes as follows
-    ///
-    /// - Write packet 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
-    /// - Write packet 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
-    ///
-    /// Where led brightness is 0..255, low to high
-    #[inline]
-    pub fn write_image(&mut self, image: &mut AniMePacketType) -> Result<(), Box<dyn Error>> {
-        if image[0][0] != ANIME_PANE1_PREFIX[0] && image[0][6] != ANIME_PANE1_PREFIX[6] {
-            image[0][..7].copy_from_slice(&ANIME_PANE1_PREFIX);
-        }
-        if image[1][0] != ANIME_PANE2_PREFIX[0] && image[1][6] != ANIME_PANE2_PREFIX[6] {
-            image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
-        }
-
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Anime", DBUS_IFACE, "SetAnime")?
-                .append2(image[0].to_vec(), image[1].to_vec());
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        thread::sleep(Duration::from_millis(self.block_time));
-        if self.stop.load(Ordering::Relaxed) {
-            panic!("Got signal to stop!");
-        }
-        Ok(())
-    }
-}

asus-nb/src/anime_matrix.rs

@@ -1,236 +0,0 @@
-pub const WIDTH: usize = 34; // Width is definitely 34 items
-pub const HEIGHT: usize = 56;
-pub type AniMeBufferType = [[u8; WIDTH]; HEIGHT];
-pub type AniMePacketType = [[u8; 640]; 2];
-const BLOCK_START: usize = 7;
-const BLOCK_END: usize = 634;
-use yansi_term::Colour::RGB;
-
-/// Helper structure for writing images.
-///
-///  See the examples for ways to write an image to `AniMeMatrix` format.
-pub struct AniMeMatrix(AniMeBufferType);
-
-impl Default for AniMeMatrix {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AniMeMatrix {
-    pub fn new() -> Self {
-        AniMeMatrix([[0u8; WIDTH]; HEIGHT])
-    }
-
-    pub fn get(&self) -> &AniMeBufferType {
-        &self.0
-    }
-
-    pub fn get_mut(&mut self) -> &mut AniMeBufferType {
-        &mut self.0
-    }
-
-    pub fn fill_with(&mut self, fill: u8) {
-        for row in self.0.iter_mut() {
-            for x in row.iter_mut() {
-                *x = fill;
-            }
-        }
-    }
-
-    pub fn debug_print(&self) {
-        // this is the index from right. It is used to progressively shorten rows
-        let mut prog_row_len = WIDTH - 2;
-
-        for (count, row) in self.0.iter().enumerate() {
-            // Write the top block of LEDs (first 7 rows)
-            if count < 6 {
-                if count % 2 != 0 {
-                    print!("     ");
-                } else {
-                    print!("  ");
-                }
-                let tmp = if count == 0 || count == 1 || count == 3 || count == 5 {
-                    row[1..].iter()
-                } else {
-                    row.iter()
-                };
-                for x in tmp {
-                    print!(" {}", RGB(*x, *x, *x).paint(&format!("{:#04X}", x)));
-                }
-
-                println!();
-            } else {
-                // Switch to next block (looks like )
-                if count % 2 != 0 {
-                    // Row after 6 is only 1 less, then rows after 7 follow pattern
-                    if count == 7 {
-                        prog_row_len -= 1;
-                    } else {
-                        prog_row_len -= 2;
-                    }
-                } else {
-                    prog_row_len += 1; // if count 6, 0
-                }
-
-                let index = row.len() - prog_row_len;
-
-                if count % 2 == 0 {
-                    print!("  ");
-                }
-                for (i, x) in row.iter().enumerate() {
-                    if i >= index {
-                        print!(" {}", RGB(*x, *x, *x).paint(&format!("{:#04X}", x)));
-                    } else {
-                        print!("     ");
-                    }
-                }
-                println!();
-            }
-        }
-    }
-}
-
-impl From<AniMeMatrix> for AniMePacketType {
-    /// Do conversion from the nested Vec in AniMeMatrix to the two required
-    /// packets suitable for sending over USB
-    #[inline]
-    fn from(anime: AniMeMatrix) -> Self {
-        let mut buffers = [[0; 640]; 2];
-
-        let mut write_index = BLOCK_START;
-        let mut write_block = &mut buffers[0];
-        let mut block1_done = false;
-
-        // this is the index from right. It is used to progressively shorten rows
-        let mut prog_row_len = WIDTH - 2;
-
-        for (count, row) in anime.0.iter().enumerate() {
-            // Write the top block of LEDs (first 7 rows)
-            if count < 6 {
-                for (i, x) in row.iter().enumerate() {
-                    // Rows 0, 1, 3, 5 are short and misaligned
-                    if count == 0 || count == 1 || count == 3 || count == 5 {
-                        if i > 0 {
-                            write_block[write_index - 1] = *x;
-                        }
-                    } else {
-                        write_block[write_index] = *x;
-                    }
-                    write_index += 1;
-                }
-            } else {
-                // Switch to next block (looks like )
-                if count % 2 != 0 {
-                    // Row after 6 is only 1 less, then rows after 7 follow pattern
-                    if count == 7 {
-                        prog_row_len -= 1;
-                    } else {
-                        prog_row_len -= 2;
-                    }
-                } else {
-                    prog_row_len += 1; // if count 6, 0
-                }
-
-                let index = row.len() - prog_row_len;
-                for n in row.iter().skip(index) {
-                    // Require a special case to catch the correct end-of-packet which is
-                    // 6 bytes from the end
-                    if write_index == BLOCK_END && !block1_done {
-                        block1_done = true;
-                        write_block = &mut buffers[1];
-                        write_index = BLOCK_START;
-                    }
-
-                    write_block[write_index] = *n;
-                    write_index += 1;
-                }
-            }
-        }
-        buffers
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::anime_matrix::{AniMeMatrix, AniMePacketType};
-
-    #[test]
-    fn check_data_alignment() {
-        let mut matrix = AniMeMatrix::new();
-        {
-            let tmp = matrix.get_mut();
-            for row in tmp.iter_mut() {
-                row[row.len() - 1] = 0xff;
-            }
-        }
-
-        let matrix: AniMePacketType = AniMePacketType::from(matrix);
-
-        // The bytes at the right of the initial AniMeMatrix should always end up aligned in the
-        // same place after conversion to data packets
-
-        // Check against manually worked out right align
-        assert_eq!(
-            matrix[0].to_vec(),
-            [
-                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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 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, 0, 0, 0, 0, 255, 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, 0, 0, 0, 0, 0, 255,
-                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, 0, 0, 0, 255, 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, 0, 0, 0, 0, 0, 255, 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, 0, 0, 0, 255, 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, 0, 0, 0, 0, 255, 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,
-                0, 0, 255, 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, 0, 0, 0, 255, 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, 0, 255, 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, 0, 0, 255, 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, 255, 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, 0, 255, 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, 255,
-                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, 255, 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, 255, 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, 255, 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, 255, 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, 255, 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, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-            ]
-            .to_vec()
-        );
-        assert_eq!(
-            matrix[1].to_vec(),
-            [
-                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, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                255, 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,
-                255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 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, 0, 0, 0,
-                255, 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, 255, 0, 0, 0,
-                0, 0, 0, 0
-            ]
-            .to_vec()
-        );
-    }
-}

asus-nb/src/aura_modes.rs

@@ -1,287 +0,0 @@
-use crate::cli_options;
-use crate::cli_options::SetAuraBuiltin;
-use serde_derive::{Deserialize, Serialize};
-
-pub const STATIC: u8 = 0x00;
-pub const BREATHING: u8 = 0x01;
-pub const STROBE: u8 = 0x02;
-pub const RAINBOW: u8 = 0x03;
-pub const STAR: u8 = 0x04;
-pub const RAIN: u8 = 0x05;
-pub const HIGHLIGHT: u8 = 0x06;
-pub const LASER: u8 = 0x07;
-pub const RIPPLE: u8 = 0x08;
-pub const PULSE: u8 = 0x0a;
-pub const COMET: u8 = 0x0b;
-pub const FLASH: u8 = 0x0c;
-pub const MULTISTATIC: u8 = 0x0d;
-pub const PER_KEY: u8 = 0xff;
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl From<cli_options::Colour> for Colour {
-    fn from(c: cli_options::Colour) -> Self {
-        Colour(c.0, c.1, c.2)
-    }
-}
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(128, 0, 0)
-    }
-}
-
-#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl From<cli_options::Speed> for Speed {
-    fn from(s: cli_options::Speed) -> Self {
-        match s {
-            cli_options::Speed::Low => Speed::Low,
-            cli_options::Speed::Med => Speed::Med,
-            cli_options::Speed::High => Speed::High,
-        }
-    }
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl From<cli_options::Direction> for Direction {
-    fn from(s: cli_options::Direction) -> Self {
-        match s {
-            cli_options::Direction::Right => Direction::Right,
-            cli_options::Direction::Left => Direction::Left,
-            cli_options::Direction::Up => Direction::Up,
-            cli_options::Direction::Down => Direction::Down,
-        }
-    }
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    pub colour: Colour,
-    pub colour2: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::TwoColourSpeed> for TwoColourSpeed {
-    fn from(mode: cli_options::TwoColourSpeed) -> Self {
-        TwoColourSpeed {
-            colour: mode.colour.into(),
-            colour2: mode.colour2.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeed> for SingleSpeed {
-    fn from(mode: cli_options::SingleSpeed) -> Self {
-        SingleSpeed {
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleColour {
-    pub colour: Colour,
-}
-impl From<cli_options::SingleColour> for SingleColour {
-    fn from(mode: cli_options::SingleColour) -> Self {
-        SingleColour {
-            colour: mode.colour.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct MultiColour {
-    pub colour1: Colour,
-    pub colour2: Colour,
-    pub colour3: Colour,
-    pub colour4: Colour,
-}
-impl From<cli_options::MultiColour> for MultiColour {
-    fn from(mode: cli_options::MultiColour) -> Self {
-        MultiColour {
-            colour1: mode.colour1.into(),
-            colour2: mode.colour2.into(),
-            colour3: mode.colour3.into(),
-            colour4: mode.colour4.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    pub direction: Direction,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeedDirection> for SingleSpeedDirection {
-    fn from(mode: cli_options::SingleSpeedDirection) -> Self {
-        SingleSpeedDirection {
-            direction: mode.direction.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    pub colour: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleColourSpeed> for SingleColourSpeed {
-    fn from(mode: cli_options::SingleColourSpeed) -> Self {
-        SingleColourSpeed {
-            colour: mode.colour.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub enum AuraModes {
-    Static(SingleColour),
-    Breathe(TwoColourSpeed),
-    Strobe(SingleSpeed),
-    Rainbow(SingleSpeedDirection),
-    Star(TwoColourSpeed),
-    Rain(SingleSpeed),
-    Highlight(SingleColourSpeed),
-    Laser(SingleColourSpeed),
-    Ripple(SingleColourSpeed),
-    Pulse(SingleColour),
-    Comet(SingleColour),
-    Flash(SingleColour),
-    MultiStatic(MultiColour),
-    LedBrightness(u8),
-    // TODO: use a serializable structure for this (KeyColourArray)
-    PerKey(Vec<Vec<u8>>),
-}
-
-impl From<SetAuraBuiltin> for AuraModes {
-    fn from(mode: SetAuraBuiltin) -> Self {
-        match mode {
-            SetAuraBuiltin::Static(x) => AuraModes::Static(x.into()),
-            SetAuraBuiltin::Breathe(x) => AuraModes::Breathe(x.into()),
-            SetAuraBuiltin::Strobe(x) => AuraModes::Strobe(x.into()),
-            SetAuraBuiltin::Rainbow(x) => AuraModes::Rainbow(x.into()),
-            SetAuraBuiltin::Star(x) => AuraModes::Star(x.into()),
-            SetAuraBuiltin::Rain(x) => AuraModes::Rain(x.into()),
-            SetAuraBuiltin::Highlight(x) => AuraModes::Highlight(x.into()),
-            SetAuraBuiltin::Laser(x) => AuraModes::Laser(x.into()),
-            SetAuraBuiltin::Ripple(x) => AuraModes::Ripple(x.into()),
-            SetAuraBuiltin::Pulse(x) => AuraModes::Pulse(x.into()),
-            SetAuraBuiltin::Comet(x) => AuraModes::Comet(x.into()),
-            SetAuraBuiltin::Flash(x) => AuraModes::Flash(x.into()),
-            SetAuraBuiltin::MultiStatic(x) => AuraModes::MultiStatic(x.into()),
-        }
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<AuraModes> for u8 {
-    fn from(mode: AuraModes) -> Self {
-        u8::from(&mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&mut AuraModes> for u8 {
-    fn from(mode: &mut AuraModes) -> Self {
-        u8::from(&*mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&AuraModes> for u8 {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => STATIC,
-            AuraModes::Breathe(_) => BREATHING,
-            AuraModes::Strobe(_) => STROBE,
-            AuraModes::Rainbow(_) => RAINBOW,
-            AuraModes::Star(_) => STAR,
-            AuraModes::Rain(_) => RAIN,
-            AuraModes::Highlight(_) => HIGHLIGHT,
-            AuraModes::Laser(_) => LASER,
-            AuraModes::Ripple(_) => RIPPLE,
-            AuraModes::Pulse(_) => PULSE,
-            AuraModes::Comet(_) => COMET,
-            AuraModes::Flash(_) => FLASH,
-            AuraModes::MultiStatic(_) => MULTISTATIC,
-            AuraModes::PerKey(_) => PER_KEY,
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-impl From<&AuraModes> for &str {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => "Static",
-            AuraModes::Breathe(_) => "Breathing",
-            AuraModes::Strobe(_) => "Strobing",
-            AuraModes::Rainbow(_) => "Rainbow",
-            AuraModes::Star(_) => "Stars",
-            AuraModes::Rain(_) => "Rain",
-            AuraModes::Highlight(_) => "Keypress Highlight",
-            AuraModes::Laser(_) => "Keypress Laser",
-            AuraModes::Ripple(_) => "Keypress Ripple",
-            AuraModes::Pulse(_) => "Pulse",
-            AuraModes::Comet(_) => "Comet",
-            AuraModes::Flash(_) => "Flash",
-            AuraModes::MultiStatic(_) => "4-Zone Static Colours",
-            AuraModes::PerKey(_) => "RGB per-key",
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-/// Exists to convert back from correct bytes. PER_KEY byte intentionally left off as it
-/// does not correspond to an actual pre-set mode, nor does brightness.
-impl From<u8> for AuraModes {
-    fn from(byte: u8) -> Self {
-        match byte {
-            STATIC => AuraModes::Static(SingleColour::default()),
-            BREATHING => AuraModes::Breathe(TwoColourSpeed::default()),
-            STROBE => AuraModes::Strobe(SingleSpeed::default()),
-            RAINBOW => AuraModes::Rainbow(SingleSpeedDirection::default()),
-            STAR => AuraModes::Star(TwoColourSpeed::default()),
-            RAIN => AuraModes::Rain(SingleSpeed::default()),
-            HIGHLIGHT => AuraModes::Highlight(SingleColourSpeed::default()),
-            LASER => AuraModes::Laser(SingleColourSpeed::default()),
-            RIPPLE => AuraModes::Ripple(SingleColourSpeed::default()),
-            PULSE => AuraModes::Pulse(SingleColour::default()),
-            COMET => AuraModes::Comet(SingleColour::default()),
-            FLASH => AuraModes::Flash(SingleColour::default()),
-            MULTISTATIC => AuraModes::MultiStatic(MultiColour::default()),
-            PER_KEY => AuraModes::PerKey(vec![]),
-            _ => panic!("Invalid mode byte"),
-        }
-    }
-}

asus-nb/src/cli_options.rs

@@ -1,215 +0,0 @@
-use crate::error::AuraError;
-use gumdrop::Options;
-use serde_derive::{Deserialize, Serialize};
-use std::str::FromStr;
-
-#[derive(Options)]
-pub struct LedBrightness {
-    level: u8,
-}
-impl LedBrightness {
-    pub fn level(&self) -> u8 {
-        self.level
-    }
-}
-impl FromStr for LedBrightness {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "off" => Ok(LedBrightness { level: 0x00 }),
-            "low" => Ok(LedBrightness { level: 0x01 }),
-            "med" => Ok(LedBrightness { level: 0x02 }),
-            "high" => Ok(LedBrightness { level: 0x03 }),
-            _ => {
-                println!("Missing required argument, must be one of:\noff,low,med,high\n");
-                Err(AuraError::ParseBrightness)
-            }
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(255, 0, 0)
-    }
-}
-impl FromStr for Colour {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.len() < 6 {
-            return Err(AuraError::ParseColour);
-        }
-        let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
-        let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
-        let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
-        Ok(Colour(r, g, b))
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-impl FromStr for Speed {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "low" => Ok(Speed::Low),
-            "med" => Ok(Speed::Med),
-            "high" => Ok(Speed::High),
-            _ => Err(AuraError::ParseSpeed),
-        }
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-impl FromStr for Direction {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "right" => Ok(Direction::Right),
-            "up" => Ok(Direction::Up),
-            "down" => Ok(Direction::Down),
-            "left" => Ok(Direction::Left),
-            _ => Err(AuraError::ParseDirection),
-        }
-    }
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the first RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, meta = "HEX", help = "set the second RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct MultiColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour1: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour3: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour4: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        meta = "DIR",
-        help = "set the direction: up, down, left, right"
-    )]
-    pub direction: Direction,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-/// Byte value for setting the built-in mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Options, Deserialize, Serialize)]
-pub enum SetAuraBuiltin {
-    #[options(help = "set a single static colour")]
-    Static(SingleColour),
-    #[options(help = "pulse between one or two colours")]
-    Breathe(TwoColourSpeed),
-    #[options(help = "strobe through all colours")]
-    Strobe(SingleSpeed),
-    #[options(help = "rainbow cycling in one of four directions")]
-    Rainbow(SingleSpeedDirection),
-    #[options(help = "rain pattern mimicking raindrops")]
-    Star(TwoColourSpeed),
-    #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed),
-    #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed),
-    #[options(help = "pressed keys generate horizontal laser")]
-    Laser(SingleColourSpeed),
-    #[options(help = "pressed keys ripple outwards like a splash")]
-    Ripple(SingleColourSpeed),
-    #[options(help = "set a rapid pulse")]
-    Pulse(SingleColour),
-    #[options(help = "set a vertical line zooming from left")]
-    Comet(SingleColour),
-    #[options(help = "set a wide vertical line zooming from left")]
-    Flash(SingleColour),
-    #[options(help = "4-zone multi-colour")]
-    MultiStatic(MultiColour),
-}
-
-impl Default for SetAuraBuiltin {
-    fn default() -> Self {
-        SetAuraBuiltin::Static(SingleColour {
-            help: false,
-            colour: Colour(255, 0, 0),
-        })
-    }
-}

asus-nb/src/core_dbus.rs

@@ -1,273 +0,0 @@
-use super::*;
-use crate::fancy::KeyColourArray;
-use crate::profile::ProfileEvent;
-use ctrl_gfx::vendors::GfxVendors;
-use dbus::channel::Sender;
-use dbus::{blocking::Connection, Message};
-use std::error::Error;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc, Mutex,
-};
-use std::{thread, time::Duration};
-
-use crate::dbus_gfx::OrgAsuslinuxDaemonNotifyGfx;
-use crate::dbus_ledmode::OrgAsuslinuxDaemonNotifyLed;
-use crate::dbus_profile::OrgAsuslinuxDaemonNotifyProfile;
-use crate::dbus_charge::OrgAsuslinuxDaemonNotifyCharge;
-
-// Signals separated out
-pub struct CtrlSignals {
-    pub gfx_signal: Arc<Mutex<Option<String>>>,
-    pub profile_signal: Arc<Mutex<Option<String>>>,
-    pub ledmode_signal: Arc<Mutex<Option<AuraModes>>>,
-    pub charge_signal: Arc<Mutex<Option<u8>>>,
-}
-
-impl CtrlSignals {
-    #[inline]
-    pub fn new(connection: &Connection) -> Result<Self, Box<dyn Error>> {
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Gfx",
-            Duration::from_millis(5000),
-        );
-
-        let gfx_signal = Arc::new(Mutex::new(None));
-        let gfx_res1 = gfx_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyGfx, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = gfx_res1.lock() {
-                    *lock = Some(sig.vendor);
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Profile",
-            Duration::from_millis(5000),
-        );
-
-        let profile_signal = Arc::new(Mutex::new(None));
-        let prof_res1 = profile_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyProfile, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = prof_res1.lock() {
-                    *lock = Some(sig.profile);
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Led",
-            Duration::from_millis(5000),
-        );
-
-        let ledmode_signal = Arc::new(Mutex::new(None));
-        let led_res1 = ledmode_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyLed, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = led_res1.lock() {
-                    if let Ok(dat) = serde_json::from_str(&sig.data) {
-                        *lock = Some(dat);
-                    }
-                }
-                true
-            },
-        )?;
-
-        //
-        let proxy = connection.with_proxy(
-            "org.asuslinux.Daemon",
-            "/org/asuslinux/Charge",
-            Duration::from_millis(5000),
-        );
-
-        let charge_signal = Arc::new(Mutex::new(None));
-        let charge_res1 = charge_signal.clone();
-
-        let _x = proxy.match_signal(
-            move |sig: OrgAsuslinuxDaemonNotifyCharge, _: &Connection, _: &Message| {
-                if let Ok(mut lock) = charge_res1.lock() {
-                        *lock = Some(sig.limit);
-                }
-                true
-            },
-        )?;
-
-        Ok(CtrlSignals {
-            gfx_signal,
-            profile_signal,
-            ledmode_signal,
-            charge_signal,
-        })
-    }
-}
-
-/// Simplified way to write a effect block
-pub struct AuraDbusClient {
-    connection: Box<Connection>,
-    block_time: u64,
-    stop: Arc<AtomicBool>,
-    signals: CtrlSignals,
-}
-
-impl AuraDbusClient {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-
-        let stop = Arc::new(AtomicBool::new(false));
-        let match_rule = dbus::message::MatchRule::new_signal(DBUS_IFACE, "NotifyLed");
-        let stop1 = stop.clone();
-        connection.add_match(match_rule, move |_: (), _, msg| {
-            if msg.read1::<&str>().is_ok() {
-                stop1.clone().store(true, Ordering::Relaxed);
-            }
-            true
-        })?;
-
-        let signals = CtrlSignals::new(&connection)?;
-
-        Ok(AuraDbusClient {
-            connection: Box::new(connection),
-            block_time: 33333,
-            stop,
-            signals,
-        })
-    }
-
-    pub fn wait_gfx_changed(&self) -> Result<String, Box<dyn Error>> {
-        loop {
-            self.connection.process(Duration::from_micros(500))?;
-            if let Ok(lock) = self.signals.gfx_signal.lock() {
-                if let Some(stuff) = lock.as_ref() {
-                    return Ok(stuff.to_string());
-                }
-            }
-        }
-    }
-
-    /// This method must always be called before the very first write to initialise
-    /// the keyboard LED EC in the correct mode
-    #[inline]
-    pub fn init_effect(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let mode = AuraModes::PerKey(vec![vec![]]);
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
-                .append1(serde_json::to_string(&mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    /// Write a single colour block.
-    ///
-    /// Intentionally blocks for 10ms after sending to allow the block to
-    /// be written to the keyboard EC. This should not be async.
-    #[inline]
-    pub fn write_colour_block(
-        &mut self,
-        key_colour_array: &KeyColourArray,
-    ) -> Result<(), Box<dyn Error>> {
-        let group = key_colour_array.get();
-        let mut vecs = Vec::with_capacity(group.len());
-        for v in group {
-            vecs.push(v.to_vec());
-        }
-        let mode = AuraModes::PerKey(vecs);
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
-                .append1(serde_json::to_string(&mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        thread::sleep(Duration::from_micros(self.block_time));
-        self.connection.process(Duration::from_micros(500))?;
-        if self.stop.load(Ordering::Relaxed) {
-            println!("Keyboard backlight was changed, exiting");
-            std::process::exit(1)
-        }
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_keyboard_leds(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
-                .append1(serde_json::to_string(mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_fan_mode(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(
-            DBUS_NAME,
-            "/org/asuslinux/Profile",
-            DBUS_IFACE,
-            "SetProfile",
-        )?
-        .append1(serde_json::to_string(&ProfileEvent::ChangeMode(level))?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_gfx_mode(&self, vendor: GfxVendors) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Gfx", DBUS_IFACE, "SetVendor")?
-                .append1(<&str>::from(&vendor));
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_profile_command(
-        &self,
-        cmd: &ProfileEvent,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(
-            DBUS_NAME,
-            "/org/asuslinux/Profile",
-            DBUS_IFACE,
-            "SetProfile",
-        )?
-        .append1(serde_json::to_string(cmd)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_charge_limit(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Charge", DBUS_IFACE, "SetLimit")?
-                .append1(level);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_builtin_mode(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(mode)
-    }
-
-    #[inline]
-    pub fn write_brightness(&self, level: u8) -> Result<String, Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(&AuraModes::LedBrightness(level))?;
-        Ok(String::new())
-    }
-}

asus-nb/src/dbus_charge.rs

@@ -1,46 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Charge -m None`, see https://github.com/diwic/dbus-rs
-use dbus as dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error>;
-    fn limit(&self) -> Result<i16, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslinuxDaemon for blocking::Proxy<'a, C> {
-
-    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetLimit", (limit, ))
-    }
-
-    fn limit(&self) -> Result<i16, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Limit", ())
-            .and_then(|r: (i16, )| Ok(r.0, ))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyCharge {
-    pub limit: u8,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyCharge {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.limit, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyCharge {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyCharge {
-            limit: i.read()?,
-        })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyCharge {
-    const NAME: &'static str = "NotifyCharge";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_gfx.rs

@@ -1,39 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -p /org/asuslinux/Gfx -m None -f org.asuslinux.Daemon -c blocking`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetVendor", (vendor,))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyGfx {
-    pub vendor: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyGfx {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.vendor, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyGfx {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyGfx { vendor: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyGfx {
-    const NAME: &'static str = "NotifyGfx";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_ledmode.rs

@@ -1,52 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Led -m None`, see https://github.com/diwic/dbus-rs
-use dbus as dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error>;
-    fn led_mode(&self) -> Result<String, dbus::Error>;
-    fn led_modes(&self) -> Result<String, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslinuxDaemon for blocking::Proxy<'a, C> {
-
-    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetLedMode", (data, ))
-    }
-
-    fn led_mode(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "LedMode", ())
-            .and_then(|r: (String, )| Ok(r.0, ))
-    }
-
-    fn led_modes(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "LedModes", ())
-            .and_then(|r: (String, )| Ok(r.0, ))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyLed {
-    pub data: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyLed {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.data, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyLed {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyLed {
-            data: i.read()?,
-        })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyLed {
-    const NAME: &'static str = "NotifyLed";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/dbus_profile.rs

@@ -1,51 +0,0 @@
-// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Profile -m None`, see https://github.com/diwic/dbus-rs
-use dbus;
-#[allow(unused_imports)]
-use dbus::arg;
-use dbus::blocking;
-
-pub trait OrgAsuslinuxDaemon {
-    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error>;
-    fn profile(&self) -> Result<String, dbus::Error>;
-    fn profiles(&self) -> Result<String, dbus::Error>;
-}
-
-impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
-    for blocking::Proxy<'a, C>
-{
-    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "SetProfile", (profile,))
-    }
-
-    fn profile(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Profile", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-
-    fn profiles(&self) -> Result<String, dbus::Error> {
-        self.method_call("org.asuslinux.Daemon", "Profiles", ())
-            .and_then(|r: (String,)| Ok(r.0))
-    }
-}
-
-#[derive(Debug)]
-pub struct OrgAsuslinuxDaemonNotifyProfile {
-    pub profile: String,
-}
-
-impl arg::AppendAll for OrgAsuslinuxDaemonNotifyProfile {
-    fn append(&self, i: &mut arg::IterAppend) {
-        arg::RefArg::append(&self.profile, i);
-    }
-}
-
-impl arg::ReadAll for OrgAsuslinuxDaemonNotifyProfile {
-    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
-        Ok(OrgAsuslinuxDaemonNotifyProfile { profile: i.read()? })
-    }
-}
-
-impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyProfile {
-    const NAME: &'static str = "NotifyProfile";
-    const INTERFACE: &'static str = "org.asuslinux.Daemon";
-}

asus-nb/src/error.rs

@@ -1,40 +0,0 @@
-use std::error::Error;
-use std::fmt;
-
-#[derive(Debug)]
-pub enum AuraError {
-    ParseColour,
-    ParseSpeed,
-    ParseDirection,
-    ParseBrightness,
-}
-
-impl fmt::Display for AuraError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            AuraError::ParseColour => write!(f, "Could not parse colour"),
-            AuraError::ParseSpeed => write!(f, "Could not parse speed"),
-            AuraError::ParseDirection => write!(f, "Could not parse direction"),
-            AuraError::ParseBrightness => write!(f, "Could not parse brightness"),
-        }
-    }
-}
-
-impl Error for AuraError {}
-
-#[derive(Debug)]
-pub enum GraphicsError {
-    ParseVendor,
-}
-
-impl fmt::Display for GraphicsError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GraphicsError::ParseVendor => write!(f, "Could not parse vendor name"),
-        }
-    }
-}
-
-impl Error for GraphicsError {}

asus-nb/src/fancy.rs

@@ -1,455 +0,0 @@
-/// A `KeyColourArray` contains all data to change the full set of keyboard
-/// key colours individually.
-///
-/// Each row of the internal array is a full HID packet that can be sent
-/// to the keyboard EC. One row controls one group of keys, these keys are not
-/// necessarily all on the same row of the keyboard, with some splitting between
-/// two rows.
-#[derive(Clone)]
-pub struct KeyColourArray([[u8; 64]; 11]);
-impl Default for KeyColourArray {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl KeyColourArray {
-    pub fn new() -> Self {
-        let mut set = [[0u8; 64]; 11];
-        for (count, row) in set.iter_mut().enumerate() {
-            row[0] = 0x5d; // Report ID
-            row[1] = 0xbc; // Mode = custom??, 0xb3 is builtin
-            row[2] = 0x00;
-            row[3] = 0x01; // ??
-            row[4] = 0x01; // ??, 4,5,6 are normally RGB for builtin mode colours
-            row[5] = 0x01; // ??
-            row[6] = (count as u8) << 4; // Key group
-            if count == 10 {
-                row[7] = 0x08; // 0b00001000
-            } else {
-                row[7] = 0x10; // 0b00010000 addressing? flips for group a0
-            }
-            row[8] = 0x00;
-        }
-        KeyColourArray(set)
-    }
-
-    /// Initialise and clear the keyboard for custom effects
-    #[inline]
-    pub fn get_init_msg() -> Vec<u8> {
-        let mut init = vec![0u8; 64];
-        init[0] = 0x5d; // Report ID
-        init[1] = 0xbc; // Mode = custom??, 0xb3 is builtin
-        init
-    }
-
-    #[inline]
-    pub fn set(&mut self, key: Key, r: u8, g: u8, b: u8) {
-        if let Some((rr, gg, bb)) = self.key(key) {
-            *rr = r;
-            *gg = g;
-            *bb = b;
-        }
-    }
-
-    /// Indexes in to `KeyColourArray` at the correct row and column
-    /// to set a series of three bytes to the chosen R,G,B values
-    pub fn key(&mut self, key: Key) -> Option<(&mut u8, &mut u8, &mut u8)> {
-        // Tuples are indexes in to array
-        let (row, col) = match key {
-            Key::VolDown => (0, 15),
-            Key::VolUp => (0, 18),
-            Key::MicMute => (0, 21),
-            Key::ROG => (0, 24),
-            //
-            Key::Esc => (1, 24),
-            Key::F1 => (1, 30),
-            Key::F2 => (1, 33),
-            Key::F3 => (1, 36),
-            Key::F4 => (1, 39),
-            Key::F5 => (1, 45),
-            Key::F6 => (1, 48),
-            Key::F7 => (1, 51),
-            Key::F8 => (1, 54),
-            //
-            Key::F9 => (2, 12),
-            Key::F10 => (2, 15),
-            Key::F11 => (2, 18),
-            Key::F12 => (2, 21),
-            Key::Del => (2, 24),
-            Key::Tilde => (2, 39),
-            Key::N1 => (2, 42),
-            Key::N2 => (2, 45),
-            Key::N3 => (2, 48),
-            Key::N4 => (2, 51),
-            Key::N5 => (2, 54),
-            //
-            Key::N6 => (3, 9),
-            Key::N7 => (3, 12),
-            Key::N8 => (3, 15),
-            Key::N9 => (3, 18),
-            Key::N0 => (3, 21),
-            Key::Hyphen => (3, 24),
-            Key::Equals => (3, 27),
-            Key::BkSpc1 => (3, 30),
-            Key::BkSpc2 => (3, 33),
-            Key::BkSpc3 => (3, 36),
-            Key::Home => (3, 39),
-            Key::Tab => (3, 54),
-            //
-            Key::Q => (4, 9),
-            Key::W => (4, 12),
-            Key::E => (4, 15),
-            Key::R => (4, 18),
-            Key::T => (4, 21),
-            Key::Y => (4, 24),
-            Key::U => (4, 27),
-            Key::I => (4, 30),
-            Key::O => (4, 33),
-            Key::P => (4, 36),
-            Key::LBracket => (4, 39),
-            Key::RBracket => (4, 42),
-            Key::BackSlash => (4, 45),
-            Key::PgUp => (4, 54),
-            //
-            Key::Caps => (5, 21),
-            Key::A => (5, 24),
-            Key::S => (5, 27),
-            Key::D => (5, 30),
-            Key::F => (5, 33),
-            Key::G => (5, 36),
-            Key::H => (5, 39),
-            Key::J => (5, 42),
-            Key::K => (5, 45),
-            Key::L => (5, 48),
-            Key::SemiColon => (5, 51),
-            Key::Quote => (5, 54),
-            //
-            Key::Ret1 => (6, 12),
-            Key::Ret2 => (6, 15),
-            Key::Ret3 => (6, 18),
-            Key::PgDn => (6, 21),
-            Key::LShift => (6, 36),
-            Key::Z => (6, 42),
-            Key::X => (6, 45),
-            Key::C => (6, 48),
-            Key::V => (6, 51),
-            Key::B => (6, 54),
-            //
-            Key::N => (7, 9),
-            Key::M => (7, 12),
-            Key::Comma => (7, 15),
-            Key::Period => (7, 18),
-            Key::FwdSlash => (7, 21),
-            Key::Rshift1 => (7, 27),
-            Key::Rshift2 => (7, 30),
-            Key::Rshift3 => (7, 33),
-            Key::End => (7, 36),
-            Key::LCtrl => (7, 51),
-            Key::LFn => (7, 54),
-            //
-            Key::Meta => (8, 9),
-            Key::LAlt => (8, 12),
-            Key::Space1 => (8, 15),
-            Key::Space2 => (8, 18),
-            Key::Space3 => (8, 21),
-            Key::Space4 => (8, 24),
-            Key::RAlt => (8, 30),
-            Key::PrtSc => (8, 33),
-            Key::RCtrl => (8, 36),
-            Key::Up => (8, 42),
-            Key::RFn => (8, 51),
-            //
-            Key::Left => (9, 54),
-            //
-            Key::Down => (10, 9),
-            Key::Right => (10, 12),
-            Key::None => return None,
-        };
-        // LOLOLOLOLOLOLOL! Look it's safe okay
-        unsafe {
-            Some((
-                &mut *(&mut self.0[row][col] as *mut u8),
-                &mut *(&mut self.0[row][col + 1] as *mut u8),
-                &mut *(&mut self.0[row][col + 2] as *mut u8),
-            ))
-        }
-    }
-
-    #[inline]
-    pub fn get(&self) -> &[[u8; 64]; 11] {
-        &self.0
-    }
-}
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-pub enum Key {
-    VolUp,
-    VolDown,
-    MicMute,
-    ROG,
-    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,
-    BkSpc1,
-    BkSpc2,
-    BkSpc3,
-    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,
-    Ret1,
-    Ret2,
-    Ret3,
-    PgDn,
-    LShift,
-    Z,
-    X,
-    C,
-    V,
-    B,
-    N,
-    M,
-    Comma,
-    Period,
-    FwdSlash,
-    Rshift1,
-    Rshift2,
-    Rshift3,
-    End,
-    LCtrl,
-    LFn,
-    Meta,
-    LAlt,
-    Space1,
-    Space2,
-    Space3,
-    Space4,
-    RAlt,
-    PrtSc,
-    RCtrl,
-    Up,
-    Down,
-    Left,
-    Right,
-    RFn,
-    None,
-}
-
-pub trait KeyLayout {
-    fn get_rows(&self) -> &Vec<[Key; 17]>;
-}
-
-pub struct GX502Layout(Vec<[Key; 17]>);
-
-impl KeyLayout for GX502Layout {
-    fn get_rows(&self) -> &Vec<[Key; 17]> {
-        &self.0
-    }
-}
-
-impl Default for GX502Layout {
-    fn default() -> Self {
-        GX502Layout(vec![
-            [
-                Key::None,
-                Key::None,
-                Key::VolDown,
-                Key::VolUp,
-                Key::MicMute,
-                Key::ROG,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-            ],
-            [
-                Key::Esc,
-                Key::None,
-                Key::F1,
-                Key::F2,
-                Key::F3,
-                Key::F4,
-                Key::None, // not sure which key to put here
-                Key::F5,
-                Key::F6,
-                Key::F7,
-                Key::F8,
-                Key::F9,
-                Key::F9,
-                Key::F10,
-                Key::F11,
-                Key::F12,
-                Key::Del,
-            ],
-            [
-                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::BkSpc1,
-                Key::BkSpc2,
-                Key::BkSpc3,
-                Key::Home,
-            ],
-            [
-                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::BackSlash,
-                Key::BackSlash,
-                Key::PgUp,
-            ],
-            [
-                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::Quote,
-                Key::Ret1,
-                Key::Ret2,
-                Key::Ret3,
-                Key::PgDn,
-            ],
-            [
-                Key::LShift,
-                Key::LShift,
-                Key::Z,
-                Key::X,
-                Key::C,
-                Key::V,
-                Key::B,
-                Key::N,
-                Key::M,
-                Key::Comma,
-                Key::Period,
-                Key::FwdSlash,
-                Key::FwdSlash,
-                Key::Rshift1,
-                Key::Rshift2,
-                Key::Rshift3,
-                Key::End,
-            ],
-            [
-                Key::LCtrl,
-                Key::LFn,
-                Key::Meta,
-                Key::LAlt,
-                Key::Space1,
-                Key::Space2,
-                Key::Space3,
-                Key::Space4,
-                Key::Space4,
-                Key::RAlt,
-                Key::PrtSc,
-                Key::RCtrl,
-                Key::RCtrl,
-                Key::Left,
-                Key::Up,
-                Key::Right,
-                Key::RFn,
-            ],
-            [
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::Left,
-                Key::Down,
-                Key::Right,
-                Key::None,
-            ],
-        ])
-    }
-}

asus-nb/src/lib.rs

@@ -1,259 +0,0 @@
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
-pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
-pub const LED_MSG_LEN: usize = 17;
-
-pub mod aura_modes;
-use aura_modes::AuraModes;
-
-pub mod profile;
-
-/// Contains mostly only what is required for parsing CLI options
-pub mod cli_options;
-
-/// Enables you to create fancy RGB effects
-pub mod fancy;
-
-/// The main dbus group for system controls, e.g, fan control, keyboard LED's
-pub mod core_dbus;
-
-/// Specific dbus for writing to the AniMe Matrix display (if supported)
-pub mod anime_dbus;
-
-/// Helper functions for the AniMe display
-pub mod anime_matrix;
-
-pub mod dbus_gfx;
-pub mod dbus_ledmode;
-pub mod dbus_profile;
-pub mod dbus_charge;
-
-pub mod error;
-
-// static LED_INIT1: [u8; 2] = [0x5d, 0xb9];
-// static LED_INIT2: &str = "]ASUS Tech.Inc."; // ] == 0x5d
-// static LED_INIT3: [u8; 6] = [0x5d, 0x05, 0x20, 0x31, 0, 0x08];
-// static LED_INIT4: &str = "^ASUS Tech.Inc."; // ^ == 0x5e
-// static LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
-
-/// Writes aout the correct byte string for brightness
-///
-/// The HID descriptor looks like:
-///
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x76,        // Usage (0x76)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5A,        //   Report ID (90)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x05,        //   Report Count (5)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-pub fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
-    // TODO: check brightness range
-    [
-        0x5A, 0xBA, 0xC5, 0xC4, brightness, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ]
-}
-
-/// Parses `AuraCommands` in to packet data
-///
-/// Byte structure:
-///
-/// ```ignore
-/// | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12|
-/// |---|---|---|---|---|---|---|---|---|---|---|---|---|
-/// |5d |b3 |00 |03 |ff |00 |00 |00 |00 |00 |00 |ff |00 |
-/// ```
-///
-/// Bytes 0 and 1 should always be 5d, b3
-///
-/// On multizone laptops byte 2 is the zone number, RGB in usual
-/// place, byte 3 set to zero
-///
-/// Byte 3 sets the mode type:
-/// - 00 = static
-/// - 01 = breathe (can set two colours)
-/// - 02 = strobe (through all colours)
-/// - 03 = rainbow
-/// - 04 = star (byte 9 sets rain colour)
-/// - 05 = rain keys, red, white, turquoise
-/// - 06 = pressed keys light up and fade
-/// - 07 = pressed key emits laser
-/// - 08 = pressed key emits water ripple
-/// - 09 = no effect/not used
-/// - 0a fast pulse (no speed setting)
-/// - 0b vertical line racing to right (no speed setting)
-/// - 0c wider vertical line racing to right (no speed setting)
-///
-/// Bytes 4, 5, 6 are Red, Green, Blue
-///
-/// Byte 7 sets speed from
-/// - 0x00 = Off
-/// - 0xe1 = Slow
-/// - 0xeb = Medium
-/// - 0xf5 = Fast
-///
-/// Byte 8 sets rainbow direction:
-/// - 0x00 = rightwards
-/// - 0x01 = leftwards
-/// - 0x02 = upwards
-/// - 0x03 = downwards
-///
-/// Bytes 10, 11, 12 are Red, Green, Blue for second colour if mode supports it
-///
-/// The HID descriptor looks like:
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x79,        // Usage (0x79)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5D,        //   Report ID (93)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x1F,        //   Report Count (31)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0x91, 0x00,        //   Output (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-///
-/// This descriptor is also used for the per-key LED settings
-impl From<&AuraModes> for [u8; LED_MSG_LEN] {
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [0u8; LED_MSG_LEN];
-        msg[0] = 0x5d;
-        msg[1] = 0xb3;
-        match mode {
-            AuraModes::LedBrightness(n) => return aura_brightness_bytes(*n),
-            AuraModes::Static(_) => msg[3] = 0x00,
-            AuraModes::Breathe(_) => msg[3] = 0x01,
-            AuraModes::Strobe(_) => msg[3] = 0x02,
-            AuraModes::Rainbow(_) => msg[3] = 0x03,
-            AuraModes::Star(_) => msg[3] = 0x04,
-            AuraModes::Rain(_) => msg[3] = 0x05,
-            AuraModes::Highlight(_) => msg[3] = 0x06,
-            AuraModes::Laser(_) => msg[3] = 0x07,
-            AuraModes::Ripple(_) => msg[3] = 0x08,
-            AuraModes::Pulse(_) => msg[3] = 0x0a,
-            AuraModes::Comet(_) => msg[3] = 0x0b,
-            AuraModes::Flash(_) => msg[3] = 0x0c,
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-
-        match mode {
-            AuraModes::Rainbow(settings) => {
-                msg[7] = settings.speed as u8;
-                msg[8] = settings.direction as u8;
-            }
-            AuraModes::Star(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[9] = settings.colour2.2;
-            }
-            AuraModes::Breathe(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[10] = settings.colour2.0;
-                msg[11] = settings.colour2.1;
-                msg[12] = settings.colour2.2;
-            }
-            AuraModes::Strobe(settings) | AuraModes::Rain(settings) => {
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Highlight(settings)
-            | AuraModes::Laser(settings)
-            | AuraModes::Ripple(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Static(settings)
-            | AuraModes::Pulse(settings)
-            | AuraModes::Comet(settings)
-            | AuraModes::Flash(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-            }
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}
-
-impl From<AuraModes> for [u8; LED_MSG_LEN] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[u8; LED_MSG_LEN]>::from(&mode)
-    }
-}
-
-impl From<AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[[u8; LED_MSG_LEN]; 4]>::from(&mode)
-    }
-}
-
-impl From<&AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [[0u8; LED_MSG_LEN]; 4];
-        for (i, row) in msg.iter_mut().enumerate() {
-            row[0] = 0x5d;
-            row[1] = 0xb3;
-            row[2] = i as u8 + 1;
-        }
-
-        match mode {
-            AuraModes::MultiStatic(settings) => {
-                msg[0][4] = settings.colour1.0;
-                msg[0][5] = settings.colour1.1;
-                msg[0][6] = settings.colour1.2;
-                msg[1][4] = settings.colour2.0;
-                msg[1][5] = settings.colour2.1;
-                msg[1][6] = settings.colour2.2;
-                msg[2][4] = settings.colour3.0;
-                msg[2][5] = settings.colour3.1;
-                msg[2][6] = settings.colour3.2;
-                msg[3][4] = settings.colour4.0;
-                msg[3][5] = settings.colour4.1;
-                msg[3][6] = settings.colour4.2;
-            }
-            _ => panic!("Mode not convertable to 2D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}

asus-nb/src/profile.rs

@@ -1,95 +0,0 @@
-use gumdrop::Options;
-use rog_fan_curve::{Curve, Fan};
-use serde_derive::{Deserialize, Serialize};
-use std::str::FromStr;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum ProfileEvent {
-    Cli(ProfileCommand),
-    ChangeMode(u8),
-    Toggle,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum FanLevel {
-    Normal,
-    Boost,
-    Silent,
-}
-
-impl FromStr for FanLevel {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "normal" => Ok(FanLevel::Normal),
-            "boost" => Ok(FanLevel::Boost),
-            "silent" => Ok(FanLevel::Silent),
-            _ => Err("Invalid fan level"),
-        }
-    }
-}
-
-impl From<u8> for FanLevel {
-    fn from(n: u8) -> Self {
-        match n {
-            0 => FanLevel::Normal,
-            1 => FanLevel::Boost,
-            2 => FanLevel::Silent,
-            _ => FanLevel::Normal,
-        }
-    }
-}
-
-impl From<FanLevel> for u8 {
-    fn from(n: FanLevel) -> Self {
-        match n {
-            FanLevel::Normal => 0,
-            FanLevel::Boost => 1,
-            FanLevel::Silent => 2,
-        }
-    }
-}
-
-impl From<&FanLevel> for u8 {
-    fn from(n: &FanLevel) -> Self {
-        match n {
-            FanLevel::Normal => 0,
-            FanLevel::Boost => 1,
-            FanLevel::Silent => 2,
-        }
-    }
-}
-
-fn parse_fan_curve(data: &str) -> Result<Curve, String> {
-    let curve = Curve::from_config_str(data)?;
-    if let Err(err) = curve.check_safety(Fan::Cpu) {
-        return Err(format!("Unsafe curve {:?}", err));
-    }
-    if let Err(err) = curve.check_safety(Fan::Gpu) {
-        return Err(format!("Unsafe curve {:?}", err));
-    }
-    Ok(curve)
-}
-
-#[derive(Debug, Clone, Options, Serialize, Deserialize)]
-pub struct ProfileCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(help = "create the profile if it doesn't exist")]
-    pub create: bool,
-
-    #[options(help = "enable or disable cpu turbo")]
-    pub turbo: Option<bool>,
-    #[options(help = "set min cpu scaling (intel)")]
-    pub min_percentage: Option<u8>,
-    #[options(help = "set max cpu scaling (intel)")]
-    pub max_percentage: Option<u8>,
-
-    #[options(meta = "PWR", help = "<silent, normal, boost>")]
-    pub preset: Option<FanLevel>,
-    #[options(parse(try_from_str = "parse_fan_curve"), help = "set fan curve")]
-    pub curve: Option<Curve>,
-    #[options(free)]
-    pub profile: Option<String>,
-}

asus-notify/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "asus-notify"
-version = "1.0.0"
-authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-# serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-notify-rust = "^4.0.0"
-dbus = { version = "^0.8" }
-asus-nb = { path = "../asus-nb" }
-asus-nb-ctrl = { path = "../asus-nb-ctrl" }

asus-notify/src/main.rs

@@ -1,101 +0,0 @@
-use asus_nb::core_dbus::CtrlSignals;
-use daemon::config::{Config, Profile};
-use dbus::blocking::Connection;
-use notify_rust::{Hint, Notification, NotificationHandle};
-use std::error::Error;
-use std::time::Duration;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut cfg = Config::read_new()?;
-    let mut last_profile = String::new();
-
-    let connection = Connection::new_system()?;
-    let signals = CtrlSignals::new(&connection)?;
-
-    let mut last_profile_notif: Option<NotificationHandle> = None;
-    let mut last_led_notif: Option<NotificationHandle> = None;
-    let mut last_gfx_notif: Option<NotificationHandle> = None;
-    let mut last_chrg_notif: Option<NotificationHandle> = None;
-
-    loop {
-        std::thread::sleep(Duration::from_millis(100));
-        connection.process(std::time::Duration::from_millis(200))?;
-
-        if let Ok(mut lock) = signals.gfx_signal.lock() {
-            if let Some(vendor) = lock.take() {
-                if let Some(notif) = last_gfx_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!("Graphics mode changed to {}", vendor))?;
-                last_gfx_notif = Some(x);
-            }
-        }
-
-        if let Ok(mut lock) = signals.charge_signal.lock() {
-            if let Some(limit) = lock.take() {
-                if let Some(notif) = last_chrg_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!("Battery charge limit changed to {}", limit))?;
-                last_led_notif = Some(x);
-            }
-        }
-
-        if let Ok(mut lock) = signals.ledmode_signal.lock() {
-            if let Some(ledmode) = lock.take() {
-                if let Some(notif) = last_led_notif.take() {
-                    notif.close();
-                }
-                let x = do_notif(&format!(
-                    "Keyboard LED mode changed to {}",
-                    <&str>::from(&ledmode)
-                ))?;
-                last_led_notif = Some(x);
-            }
-        }
-
-        // We need to do the config read because of a limitation preventing
-        // easy dbus notification from the profile controller
-        cfg.read();
-        if last_profile != cfg.active_profile {
-            if let Some(notif) = last_profile_notif.take() {
-                notif.close();
-            }
-            if let Some(profile) = cfg.power_profiles.get(&cfg.active_profile) {
-                let x = do_thermal_notif(&profile, &cfg.active_profile)?;
-                last_profile_notif = Some(x);
-                last_profile = cfg.active_profile.clone();
-            }
-        }
-    }
-}
-
-fn do_thermal_notif(profile: &Profile, label: &str) -> Result<NotificationHandle, Box<dyn Error>> {
-    let fan = profile.fan_preset;
-    let turbo = if profile.turbo { "enabled" } else { "disabled" };
-    let icon = match fan {
-        0 => "asus_notif_yellow",
-        1 => "asus_notif_red",
-        2 => "asus_notif_green",
-        _ => "asus_notif_red",
-    };
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!("Thermal profile changed to {}, turbo {}", label.to_uppercase(), turbo))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
-}
-
-fn do_notif(body: &str) -> Result<NotificationHandle, Box<dyn Error>> {
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(body)
-        .timeout(2000)
-        .show()?;
-    Ok(x)
-}

asusctl/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "asusctl"
+license = "MPL-2.0"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
+rog_dbus = { path = "../rog-dbus" }
+rog_profiles = { path = "../rog-profiles" }
+rog_platform = { path = "../rog-platform" }
+daemon = { path = "../daemon" }
+
+gumdrop.workspace = true
+toml.workspace = true
+sysfs-class.workspace = true
+
+[dev-dependencies]
+gif.workspace = true
+tinybmp.workspace = true
+glam.workspace = true
+rog_dbus = { path = "../rog-dbus" }
+
+cargo-husky.workspace = true

asusctl/examples/anime-diag-png.rs

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

asusctl/examples/anime-diag.rs

@@ -0,0 +1,38 @@
+use std::thread::sleep;
+use std::time::Duration;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+// 74w x 36h diagonal used by the windows app
+
+fn main() {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+
+    for step in (2..50).rev() {
+        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;
+            }
+        }
+
+        for c in (0..35).into_iter().step_by(step) {
+            for i in &mut matrix.get_mut()[c] {
+                *i = 50;
+            }
+        }
+
+        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

@@ -0,0 +1,46 @@
+use std::env;
+use std::path::Path;
+use std::thread::sleep;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{ActionData, ActionLoader, Sequences};
+use rog_dbus::RogDbusClientBlocking;
+
+fn main() {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+
+    let args: Vec<String> = env::args().into_iter().collect();
+    if args.len() != 3 {
+        println!("Please supply filepath and brightness");
+        return;
+    }
+
+    let path = Path::new(&args[1]);
+    let brightness = args[2].parse::<f32>().unwrap();
+    let anime_type = get_anime_type().unwrap();
+    let mut seq = Sequences::new(anime_type);
+    seq.insert(
+        0,
+        &ActionLoader::AsusAnimation {
+            file: path.into(),
+            time: rog_anime::AnimTime::Infinite,
+            brightness,
+        },
+    )
+    .unwrap();
+
+    loop {
+        for action in seq.iter() {
+            if let ActionData::Animation(frames) = action {
+                for frame in frames.frames() {
+                    client
+                        .proxies()
+                        .anime()
+                        .write(frame.frame().clone())
+                        .unwrap();
+                    sleep(frame.delay());
+                }
+            }
+        }
+    }
+}

asusctl/examples/anime-grid.rs

@@ -0,0 +1,47 @@
+use std::convert::TryFrom;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeGrid};
+use rog_dbus::RogDbusClientBlocking;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+// 74w x 36h diagonal used by the windows app
+
+fn main() {
+    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;
+    for (y, row) in tmp.iter_mut().enumerate() {
+        if y % 2 == 0 && i + 1 != row.len() - 1 {
+            i += 1;
+        }
+        row[row.len() - i] = 0x22;
+        if i > 5 {
+            row[row.len() - i + 5] = 0x22;
+        }
+        if i > 10 {
+            row[row.len() - i + 10] = 0x22;
+        }
+
+        if i > 15 {
+            row[row.len() - i + 15] = 0x22;
+        }
+
+        if i > 20 {
+            row[row.len() - i + 20] = 0x22;
+        }
+
+        if i > 25 {
+            row[row.len() - i + 25] = 0x22;
+        }
+    }
+
+    let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
+
+    client.proxies().anime().write(matrix).unwrap();
+}

asusctl/examples/anime-outline.rs

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

asusctl/examples/anime-png.rs

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

asusctl/examples/anime-spinning.rs

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

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

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

asusctl/examples/aura-zoned-breathe.rs

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

asusctl/src/anime_cli.rs

@@ -0,0 +1,103 @@
+use gumdrop::Options;
+
+#[derive(Options)]
+pub struct AnimeCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        help = "enable/disable the panel LEDs (does not erase last image)"
+    )]
+    pub enable: Option<bool>,
+    #[options(
+        meta = "",
+        help = "enable/disable system animations (boot/sleep/shutdown)"
+    )]
+    pub boot_enable: Option<bool>,
+    #[options(meta = "", help = "set global AniMe brightness value")]
+    pub brightness: Option<f32>,
+    #[options(help = "clear the display")]
+    pub clear: bool,
+    #[options(command)]
+    pub command: Option<AnimeActions>,
+}
+
+#[derive(Options)]
+pub enum AnimeActions {
+    #[options(help = "display a PNG image")]
+    Image(AnimeImage),
+    #[options(help = "display a diagonal/pixel-perfect PNG")]
+    PixelImage(AnimeImageDiagonal),
+    #[options(help = "display an animated GIF")]
+    Gif(AnimeGif),
+    #[options(help = "display an animated diagonal/pixel-perfect GIF")]
+    PixelGif(AnimeGifDiagonal),
+}
+
+#[derive(Options)]
+pub struct AnimeImage {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
+    pub scale: f32,
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
+    pub x_pos: f32,
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
+    pub y_pos: f32,
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
+    pub angle: f32,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+}
+
+#[derive(Options)]
+pub struct AnimeImageDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+}
+
+#[derive(Options)]
+pub struct AnimeGif {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
+    pub scale: f32,
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
+    pub x_pos: f32,
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
+    pub y_pos: f32,
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
+    pub angle: f32,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}
+
+#[derive(Options)]
+pub struct AnimeGifDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}

asusctl/src/aura_cli.rs

@@ -0,0 +1,378 @@
+use std::str::FromStr;
+
+use gumdrop::Options;
+use rog_aura::error::Error;
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
+
+#[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>,
+}
+impl LedBrightness {
+    pub fn new(level: Option<u32>) -> Self {
+        LedBrightness { level }
+    }
+
+    pub fn level(&self) -> Option<u32> {
+        self.level
+    }
+}
+impl FromStr for LedBrightness {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "off" => Ok(LedBrightness { level: Some(0x00) }),
+            "low" => Ok(LedBrightness { level: Some(0x01) }),
+            "med" => Ok(LedBrightness { level: Some(0x02) }),
+            "high" => Ok(LedBrightness { level: Some(0x03) }),
+            _ => {
+                print!("Invalid argument, must be one of: off, low, med, high");
+                Err(Error::ParseBrightness)
+            }
+        }
+    }
+}
+impl ToString for LedBrightness {
+    fn to_string(&self) -> String {
+        let s = match self.level {
+            Some(0x00) => "low",
+            Some(0x01) => "med",
+            Some(0x02) => "high",
+            _ => "unknown",
+        };
+        s.to_owned()
+    }
+}
+
+#[derive(Debug, Clone, Options, Default)]
+pub struct SingleSpeed {
+    #[options(help = "print help message")]
+    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")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
+    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)]
+pub struct SingleColour {
+    #[options(help = "print help message")]
+    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)]
+pub struct SingleColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    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)]
+pub struct TwoColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(no_long, meta = "", help = "set the second RGB value e.g, ff00ff")]
+    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 MultiZone {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct MultiColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+/// Byte value for setting the built-in mode.
+///
+/// Enum corresponds to the required integer value
+// NOTE: The option names here must match those in rog-aura crate
+#[derive(Options)]
+pub enum SetAuraBuiltin {
+    #[options(help = "set a single static colour")]
+    Static(SingleColour),
+    #[options(help = "pulse between one or two colours")]
+    Breathe(TwoColourSpeed),
+    #[options(help = "strobe through all colours")]
+    Strobe(SingleSpeed),
+    #[options(help = "rainbow cycling in one of four directions")]
+    Rainbow(SingleSpeedDirection),
+    #[options(help = "rain pattern mimicking raindrops")]
+    Stars(TwoColourSpeed),
+    #[options(help = "rain pattern of three preset colours")]
+    Rain(SingleSpeed),
+    #[options(help = "pressed keys are highlighted to fade")]
+    Highlight(SingleColourSpeed),
+    #[options(help = "pressed keys generate horizontal laser")]
+    Laser(SingleColourSpeed),
+    #[options(help = "pressed keys ripple outwards like a splash")]
+    Ripple(SingleColourSpeed),
+    #[options(help = "set a rapid pulse")]
+    Pulse(SingleColour),
+    #[options(help = "set a vertical line zooming from left")]
+    Comet(SingleColour),
+    #[options(help = "set a wide vertical line zooming from left")]
+    Flash(SingleColour),
+}
+
+impl Default for SetAuraBuiltin {
+    fn default() -> Self {
+        SetAuraBuiltin::Static(SingleColour::default())
+    }
+}
+
+impl From<&SingleColour> for AuraEffect {
+    fn from(aura: &SingleColour) -> Self {
+        Self {
+            colour1: aura.colour,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeed> for AuraEffect {
+    fn from(aura: &SingleSpeed) -> Self {
+        Self {
+            speed: aura.speed,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleColourSpeed> for AuraEffect {
+    fn from(aura: &SingleColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            speed: aura.speed,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&TwoColourSpeed> for AuraEffect {
+    fn from(aura: &TwoColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            colour2: aura.colour2,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeedDirection> for AuraEffect {
+    fn from(aura: &SingleSpeedDirection) -> Self {
+        Self {
+            speed: aura.speed,
+            direction: aura.direction,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SetAuraBuiltin> for AuraEffect {
+    fn from(aura: &SetAuraBuiltin) -> Self {
+        match aura {
+            SetAuraBuiltin::Static(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Static;
+                data
+            }
+            SetAuraBuiltin::Breathe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Breathe;
+                data
+            }
+            SetAuraBuiltin::Strobe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Strobe;
+                data
+            }
+            SetAuraBuiltin::Rainbow(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rainbow;
+                data
+            }
+            SetAuraBuiltin::Stars(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Star;
+                data
+            }
+            SetAuraBuiltin::Rain(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rain;
+                data
+            }
+            SetAuraBuiltin::Highlight(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Highlight;
+                data
+            }
+            SetAuraBuiltin::Laser(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Laser;
+                data
+            }
+            SetAuraBuiltin::Ripple(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Ripple;
+                data
+            }
+            SetAuraBuiltin::Pulse(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Pulse;
+                data
+            }
+            SetAuraBuiltin::Comet(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Comet;
+                data
+            }
+            SetAuraBuiltin::Flash(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Flash;
+                data
+            }
+        }
+    }
+}

asusctl/src/cli_opts.rs

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

asusctl/src/main.rs

@@ -0,0 +1,832 @@
+use std::convert::TryFrom;
+use std::env::args;
+use std::path::Path;
+use std::process::Command;
+use std::thread::sleep;
+
+use anime_cli::{AnimeActions, AnimeCommand};
+use aura_cli::{LedPowerCommand1, LedPowerCommand2};
+use gumdrop::{Opt, Options};
+use profiles_cli::{FanCurveCommand, ProfileCommand};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
+use rog_aura::usb::{AuraDevRog1, AuraDevRog2, 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;
+mod aura_cli;
+mod cli_opts;
+mod profiles_cli;
+
+fn main() {
+    let args: Vec<String> = args().skip(1).collect();
+
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    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) => {
+            panic!("source {}", err);
+        }
+    };
+
+    let (dbus, _) = RogDbusClientBlocking::new()
+        .map_err(|e| {
+            print_error_help(&e, None);
+            panic!("Could not start dbus client");
+        })
+        .unwrap();
+
+    let supported = dbus
+        .proxies()
+        .supported()
+        .supported_functions()
+        .map_err(|e| {
+            print_error_help(&e, None);
+            panic!("Could not start dbus proxy");
+        })
+        .unwrap();
+
+    if parsed.version {
+        print_versions();
+        println!();
+        print_laptop_info();
+    }
+
+    if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
+        print_error_help(&*err, Some(&supported));
+    }
+}
+
+fn print_error_help(err: &dyn std::error::Error, supported: Option<&SupportedFunctions>) {
+    check_service("asusd");
+    println!("\nError: {}\n", err);
+    print_versions();
+    println!();
+    print_laptop_info();
+    if let Some(supported) = supported {
+        println!();
+        println!("Supported laptop functions:\n\n{}", supported);
+    }
+}
+
+fn print_versions() {
+    println!("App and daemon versions:");
+    println!("      asusctl v{}", env!("CARGO_PKG_VERSION"));
+    println!("        asusd v{}", daemon::VERSION);
+    println!("\nComponent crate versions:");
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-aura v{}", rog_aura::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!(" rog-profiles v{}", rog_profiles::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
+}
+
+fn print_laptop_info() {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name().expect("Could not get board_name");
+    let prod_family = dmi.product_family().expect("Could not get product_family");
+
+    println!("Product family: {}", prod_family.trim());
+    println!("Board name: {}", board_name.trim());
+}
+
+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",
+            name, name
+        );
+        return true;
+    } else if !check_systemd_unit_active(name) {
+        println!(
+            "\n\x1b[0;31m{} is not running, start it with `systemctl start {}\x1b[0m",
+            name, name
+        );
+        return true;
+    }
+    false
+}
+
+fn do_parsed(
+    parsed: &CliStart,
+    supported: &SupportedFunctions,
+    dbus: &RogDbusClientBlocking<'_>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    match &parsed.command {
+        Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
+        Some(CliCommand::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)?;
+        }
+        Some(CliCommand::Graphics(_)) => do_gfx(),
+        Some(CliCommand::Anime(cmd)) => handle_anime(dbus, &supported.anime_ctrl, cmd)?,
+        Some(CliCommand::Bios(cmd)) => handle_bios_option(dbus, &supported.rog_bios_ctrl, cmd)?,
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.chg_limit.is_none()
+                && !parsed.next_kbd_bright
+                && !parsed.prev_kbd_bright)
+                || parsed.help
+            {
+                println!("{}", CliStart::usage());
+                println!();
+                if let Some(cmdlist) = CliStart::command_list() {
+                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+                    for command in commands.iter().filter(|command| {
+                        if !matches!(
+                            supported.keyboard_led.dev_id,
+                            AuraDevice::X1854
+                                | AuraDevice::X1869
+                                | AuraDevice::X1866
+                                | AuraDevice::Tuf
+                        ) && command.trim().starts_with("led-pow-1")
+                        {
+                            return false;
+                        }
+                        if supported.keyboard_led.dev_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");
+            }
+        }
+    }
+
+    if let Some(brightness) = &parsed.kbd_bright {
+        match brightness.level() {
+            None => {
+                let level = dbus.proxies().led().led_brightness()?;
+                println!("Current keyboard led brightness: {}", level);
+            }
+            Some(level) => dbus
+                .proxies()
+                .led()
+                .set_brightness(<rog_aura::LedBrightness>::from(level))?,
+        }
+    }
+
+    if parsed.next_kbd_bright {
+        dbus.proxies().led().next_led_brightness()?;
+    }
+
+    if parsed.prev_kbd_bright {
+        dbus.proxies().led().prev_led_brightness()?;
+    }
+
+    if parsed.show_supported {
+        println!("Supported laptop functions:\n\n{}", supported);
+    }
+
+    if let Some(chg_limit) = parsed.chg_limit {
+        dbus.proxies()
+            .charge()
+            .set_charge_control_end_threshold(chg_limit)?;
+    }
+
+    Ok(())
+}
+
+fn do_gfx() {
+    println!(
+        "Please use supergfxctl for graphics switching. supergfxctl is the result of making \
+         asusctl graphics switching generic so all laptops can use it"
+    );
+    println!("This command will be removed in future");
+}
+
+fn handle_anime(
+    dbus: &RogDbusClientBlocking<'_>,
+    _supported: &AnimeSupportedFunctions,
+    cmd: &AnimeCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if (cmd.command.is_none()
+        && cmd.enable.is_none()
+        && cmd.boot_enable.is_none()
+        && cmd.brightness.is_none())
+        || cmd.help
+    {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+    }
+    if let Some(anime_turn) = cmd.enable {
+        dbus.proxies().anime().set_on_off(anime_turn)?;
+    }
+    if let Some(anime_boot) = cmd.boot_enable {
+        dbus.proxies().anime().set_boot_on_off(anime_boot)?;
+    }
+    if let Some(bright) = cmd.brightness {
+        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() {
+                    println!("Missing arg or command\n\n{}", image.self_usage());
+                    if let Some(lst) = image.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+                verify_brightness(image.bright);
+
+                let matrix = AnimeImage::from_png(
+                    Path::new(&image.path),
+                    image.scale,
+                    image.angle,
+                    Vec2::new(image.x_pos, image.y_pos),
+                    image.bright,
+                    anime_type,
+                )?;
+
+                dbus.proxies()
+                    .anime()
+                    .write(<AnimeDataBuffer>::try_from(&matrix)?)?;
+            }
+            AnimeActions::PixelImage(image) => {
+                if image.help_requested() || image.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", image.self_usage());
+                    if let Some(lst) = image.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+                verify_brightness(image.bright);
+
+                let matrix = AnimeDiagonal::from_png(
+                    Path::new(&image.path),
+                    None,
+                    image.bright,
+                    anime_type,
+                )?;
+
+                dbus.proxies()
+                    .anime()
+                    .write(matrix.into_data_buffer(anime_type)?)?;
+            }
+            AnimeActions::Gif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+                verify_brightness(gif.bright);
+
+                let matrix = AnimeGif::from_gif(
+                    Path::new(&gif.path),
+                    gif.scale,
+                    gif.angle,
+                    Vec2::new(gif.x_pos, gif.y_pos),
+                    AnimTime::Count(1),
+                    gif.bright,
+                    anime_type,
+                )?;
+
+                let mut loops = gif.loops as i32;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
+            AnimeActions::PixelGif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+                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;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    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
+        );
+    }
+}
+
+fn handle_led_mode(
+    dbus: &RogDbusClientBlocking<'_>,
+    supported: &LedSupportedFunctions,
+    mode: &LedModeCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
+        if !mode.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", mode.self_usage());
+        println!("Commands available");
+
+        if let Some(cmdlist) = LedModeCommand::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+            for command in commands.iter().filter(|command| {
+                for mode in &supported.basic_modes {
+                    if command
+                        .trim()
+                        .starts_with(&<&str>::from(mode).to_lowercase())
+                    {
+                        return true;
+                    }
+                }
+                if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
+                    return true;
+                }
+                false
+            }) {
+                println!("{}", command);
+            }
+        }
+
+        println!("\nHelp can also be requested on modes, e.g: static --help");
+        return Ok(());
+    }
+
+    if mode.next_mode && mode.prev_mode {
+        println!("Please specify either next or previous");
+        return Ok(());
+    }
+    if mode.next_mode {
+        dbus.proxies().led().next_led_mode()?;
+    } else if mode.prev_mode {
+        dbus.proxies().led().prev_led_mode()?;
+    } else if let Some(mode) = mode.command.as_ref() {
+        if mode.help_requested() {
+            println!("{}", mode.self_usage());
+            return Ok(());
+        }
+        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.dev_id,
+        AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866
+    ) {
+        handle_led_power_1_do_1866(dbus, power)?;
+        return Ok(());
+    }
+
+    if matches!(supported.dev_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<AuraDevRog1> = Vec::new();
+    let mut disabled: Vec<AuraDevRog1> = Vec::new();
+
+    let mut check = |e: Option<bool>, a: AuraDevRog1| {
+        if let Some(arg) = e {
+            if arg {
+                enabled.push(a);
+            } else {
+                disabled.push(a);
+            }
+        }
+    };
+
+    check(power.awake, AuraDevRog1::Awake);
+    check(power.boot, AuraDevRog1::Boot);
+    check(power.sleep, AuraDevRog1::Sleep);
+    check(power.keyboard, AuraDevRog1::Keyboard);
+    check(power.lightbar, AuraDevRog1::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,
+    };
+    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_owned()).collect();
+            for command in &commands {
+                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.dev_id != AuraDevice::X19b6 {
+            println!("This option applies only to keyboards with product ID 0x19b6");
+        }
+
+        let mut enabled: Vec<AuraDevRog2> = Vec::new();
+        let mut disabled: Vec<AuraDevRog2> = Vec::new();
+        let mut check = |e: Option<bool>, a: AuraDevRog2| {
+            if let Some(arg) = e {
+                if arg {
+                    enabled.push(a);
+                } else {
+                    disabled.push(a);
+                }
+            }
+        };
+
+        match pow {
+            aura_cli::SetAuraEnabled::Boot(arg) => {
+                check(arg.keyboard, AuraDevRog2::BootKeyb);
+                check(arg.logo, AuraDevRog2::BootLogo);
+                check(arg.lightbar, AuraDevRog2::BootBar);
+                check(arg.lid, AuraDevRog2::AwakeLid);
+            }
+            aura_cli::SetAuraEnabled::Sleep(arg) => {
+                check(arg.keyboard, AuraDevRog2::SleepKeyb);
+                check(arg.logo, AuraDevRog2::SleepLogo);
+                check(arg.lightbar, AuraDevRog2::SleepBar);
+                check(arg.lid, AuraDevRog2::SleepLid);
+            }
+            aura_cli::SetAuraEnabled::Awake(arg) => {
+                check(arg.keyboard, AuraDevRog2::AwakeKeyb);
+                check(arg.logo, AuraDevRog2::AwakeLogo);
+                check(arg.lightbar, AuraDevRog2::AwakeBar);
+                check(arg.lid, AuraDevRog2::AwakeLid);
+            }
+            aura_cli::SetAuraEnabled::Shutdown(arg) => {
+                check(arg.keyboard, AuraDevRog2::ShutdownKeyb);
+                check(arg.logo, AuraDevRog2::ShutdownLogo);
+                check(arg.lightbar, AuraDevRog2::ShutdownBar);
+                check(arg.lid, AuraDevRog2::ShutdownBar);
+            }
+        }
+
+        if !enabled.is_empty() {
+            let data = AuraPowerDev {
+                tuf: vec![],
+                x1866: vec![],
+                x19b6: enabled,
+            };
+            dbus.proxies().led().set_leds_power(data, true)?;
+        }
+
+        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: &RogDbusClientBlocking<'_>,
+    supported: &PlatformProfileFunctions,
+    cmd: &ProfileCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.platform_profile {
+        println!("Profiles not supported by either this kernel or by the laptop.");
+        return Err(ProfileError::NotSupported.into());
+    }
+
+    if !cmd.next && !cmd.list && cmd.profile_set.is_none() && !cmd.profile_get {
+        if !cmd.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}", ProfileCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        return Ok(());
+    }
+
+    if cmd.next {
+        dbus.proxies().profile().next_profile()?;
+    } else if let Some(profile) = cmd.profile_set {
+        dbus.proxies().profile().set_active_profile(profile)?;
+    }
+
+    if cmd.list {
+        let res = dbus.proxies().profile().profiles()?;
+        for p in &res {
+            println!("{:?}", p);
+        }
+    }
+
+    if cmd.profile_get {
+        let res = dbus.proxies().profile().active_profile()?;
+        println!("Active profile is {:?}", res);
+    }
+
+    Ok(())
+}
+
+fn handle_fan_curve(
+    dbus: &RogDbusClientBlocking<'_>,
+    supported: &PlatformProfileFunctions,
+    cmd: &FanCurveCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.fan_curves {
+        println!("Fan-curves not supported by either this kernel or by the laptop.");
+        println!("This requires kernel 5.17 or the fan curve patch listed in the readme.");
+        return Err(ProfileError::NotSupported.into());
+    }
+
+    if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
+        if !cmd.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}", FanCurveCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        return Ok(());
+    }
+
+    if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some())
+        && cmd.mod_profile.is_none()
+    {
+        println!("--enabled, --fan, and --data options require --mod-profile");
+        return Ok(());
+    }
+
+    if cmd.get_enabled {
+        let res = dbus.proxies().profile().enabled_fan_profiles()?;
+        println!("{:?}", res);
+    }
+
+    if cmd.default {
+        dbus.proxies().profile().set_active_curve_to_defaults()?;
+    }
+
+    if let Some(profile) = cmd.mod_profile {
+        if cmd.enabled.is_none() && cmd.data.is_none() {
+            let data = dbus.proxies().profile().fan_curve_data(profile)?;
+            let data = toml::to_string(&data)?;
+            println!("\nFan curves for {:?}\n\n{}", profile, data);
+        }
+
+        if let Some(enabled) = cmd.enabled {
+            dbus.proxies()
+                .profile()
+                .set_fan_curve_enabled(profile, enabled)?;
+        }
+
+        if let Some(mut curve) = cmd.data.clone() {
+            let fan = cmd.fan.unwrap_or_default();
+            curve.set_fan(fan);
+            dbus.proxies().profile().set_fan_curve(profile, curve)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_bios_option(
+    dbus: &RogDbusClientBlocking<'_>,
+    supported: &RogBiosSupportedFunctions,
+    cmd: &BiosCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    {
+        if (cmd.gpu_mux_mode_set.is_none()
+            && !cmd.gpu_mux_mode_get
+            && cmd.post_sound_set.is_none()
+            && !cmd.post_sound_get
+            && cmd.panel_overdrive_set.is_none()
+            && !cmd.panel_overdrive_get)
+            || cmd.help
+        {
+            println!("Missing arg or command\n");
+
+            let usage: Vec<String> = BiosCommand::usage().lines().map(|s| s.to_owned()).collect();
+
+            for line in usage.iter().filter(|line| {
+                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_boot_sound(opt)?;
+        }
+        if cmd.post_sound_get {
+            let res = dbus.proxies().rog_bios().post_boot_sound()? == 1;
+            println!("Bios POST sound on: {}", res);
+        }
+
+        if let Some(opt) = cmd.gpu_mux_mode_set {
+            println!("Rebuilding initrd to include drivers");
+            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 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(())
+}
+
+fn check_systemd_unit_active(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-active")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return !buf.contains("inactive") && !buf.contains("failed");
+    }
+    false
+}
+
+fn check_systemd_unit_enabled(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-enabled")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return buf.contains("enabled");
+    }
+    false
+}

asusctl/src/profiles_cli.rs

@@ -0,0 +1,52 @@
+use gumdrop::Options;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{FanCurvePU, Profile};
+
+#[derive(Debug, Clone, Options)]
+pub struct ProfileCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "toggle to next profile in list")]
+    pub next: bool,
+    #[options(help = "list available profiles")]
+    pub list: bool,
+
+    #[options(help = "get profile")]
+    pub profile_get: bool,
+    #[options(meta = "", help = "set the active profile")]
+    pub profile_set: Option<Profile>,
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct FanCurveCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "get enabled fan profiles")]
+    pub get_enabled: bool,
+    #[options(help = "set the active profile's fan curve to default")]
+    pub default: bool,
+
+    #[options(
+        meta = "",
+        help = "profile to modify fan-curve for. Shows data if no options provided"
+    )]
+    pub mod_profile: Option<Profile>,
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> fan curve. `mod-profile` required"
+    )]
+    pub enabled: Option<bool>,
+    #[options(
+        meta = "",
+        help = "select fan <cpu/gpu> to modify. `mod-profile` required"
+    )]
+    pub fan: Option<FanCurvePU>,
+
+    #[options(
+        meta = "",
+        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%.
+                      `--mod-profile` required. If '%' is omitted the fan range is 0-255"
+    )]
+    pub data: Option<CurveData>,
+}

config-traits/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "config-traits"
+license = "MPL-2.0"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+ron.workspace = true
+
+log.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

config-traits/README.md

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

config-traits/src/lib.rs

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

ctrl-gfx/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "ctrl-gfx"
-version = "2.0.0"
-license = "MPL-2.0"
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-description = "Fine control of laptop GPU"
-edition = "2018"
-
-[dependencies]
-sysfs-class = "^0.1.2"
-log = "^0.4"
-
-zbus = { version = "1.1.1", optional = true }
-zvariant = { version = "2.2.0", optional = true }
-
-[features]
-default = ["use-zbus"]
-use-zbus = ["zbus", "zvariant"]

ctrl-gfx/src/ctrl_gfx.rs

@@ -1,335 +0,0 @@
-use log::{error, info, warn};
-use std::error::Error;
-use std::io::Write;
-use std::iter::FromIterator;
-use std::path::Path;
-use std::process::Command;
-use std::str::FromStr;
-use sysfs_class::{PciDevice, SysClass};
-use zbus::dbus_interface;
-
-use crate::vendors::*;
-use crate::*;
-use crate::{error::GfxError, system::*};
-
-pub struct CtrlGraphics {
-    bus: PciBus,
-    amd: Vec<GraphicsDevice>,
-    intel: Vec<GraphicsDevice>,
-    nvidia: Vec<GraphicsDevice>,
-    #[allow(dead_code)]
-    other: Vec<GraphicsDevice>,
-    initfs_cmd: Option<Command>,
-}
-
-trait Dbus {
-    fn set_vendor(&mut self, vendor: String);
-    fn notify_gfx(&self, vendor: &str) -> zbus::Result<()>;
-}
-
-#[cfg(feature = "use-zbus")]
-use std::convert::TryInto;
-
-#[cfg(feature = "use-zbus")]
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl Dbus for CtrlGraphics {
-    fn set_vendor(&mut self, vendor: String) {
-        if let Ok(tmp) = GfxVendors::from_str(&vendor) {
-            self.set(tmp).unwrap_or_else(|err| {
-                warn!("{}", err);
-                format!("Failed: {}", err.to_string())
-            });
-            self.notify_gfx(&vendor)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-    }
-
-    #[dbus_interface(signal)]
-    fn notify_gfx(&self, vendor: &str) -> zbus::Result<()>;
-}
-
-impl CtrlGraphics {
-    pub fn new() -> std::io::Result<CtrlGraphics> {
-        let bus = PciBus::new()?;
-
-        info!("Rescanning PCI bus");
-        bus.rescan()?;
-
-        let devs = PciDevice::all()?;
-
-        let functions = |parent: &PciDevice| -> Vec<PciDevice> {
-            let mut functions = Vec::new();
-            if let Some(parent_slot) = parent.id().split('.').next() {
-                for func in devs.iter() {
-                    if let Some(func_slot) = func.id().split('.').next() {
-                        if func_slot == parent_slot {
-                            info!("{}: Function for {}", func.id(), parent.id());
-                            functions.push(func.clone());
-                        }
-                    }
-                }
-            }
-            functions
-        };
-
-        let mut amd = Vec::new();
-        let mut intel = Vec::new();
-        let mut nvidia = Vec::new();
-        let mut other = Vec::new();
-        for dev in devs.iter() {
-            let c = dev.class()?;
-            if 0x03 == (c >> 16) & 0xFF {
-                match dev.vendor()? {
-                    0x1002 => {
-                        info!("{}: AMD graphics", dev.id());
-                        amd.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x10DE => {
-                        info!("{}: NVIDIA graphics", dev.id());
-                        nvidia.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    0x8086 => {
-                        info!("{}: Intel graphics", dev.id());
-                        intel.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                    vendor => {
-                        info!("{}: Other({:X}) graphics", dev.id(), vendor);
-                        other.push(GraphicsDevice::new(dev.id().to_owned(), functions(&dev)));
-                    }
-                }
-            }
-        }
-
-        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");
-            initfs_cmd = Some(cmd);
-            info!("Using initramfs update command 'dracut'");
-        }
-
-        Ok(CtrlGraphics {
-            bus,
-            amd,
-            intel,
-            nvidia,
-            other,
-            initfs_cmd,
-        })
-    }
-
-    #[cfg(feature = "use-zbus")]
-    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&"/org/asuslinux/Gfx".try_into().unwrap(), self)
-            .unwrap();
-    }
-
-    pub fn reload(&mut self) -> Result<(), Box<dyn Error>> {
-        self.auto_power()?;
-        info!("Reloaded gfx mode: {:?}", CtrlGraphics::get_vendor()?);
-        Ok(())
-    }
-
-    fn can_switch(&self) -> bool {
-        !self.nvidia.is_empty() && (!self.intel.is_empty() || !self.amd.is_empty())
-    }
-
-    fn get_prime_discrete() -> Result<String, GfxError> {
-        let s = std::fs::read_to_string(PRIME_DISCRETE_PATH)
-            .map_err(|err| GfxError::Read(PRIME_DISCRETE_PATH.into(), err))?
-            .trim()
-            .to_owned();
-        Ok(s)
-    }
-
-    fn set_prime_discrete(mode: &str) -> Result<(), GfxError> {
-        std::fs::write(PRIME_DISCRETE_PATH, mode)
-            .map_err(|err| GfxError::Read(PRIME_DISCRETE_PATH.into(), err))?;
-        Ok(())
-    }
-
-    /// Associated method to get which vendor mode is set
-    pub fn get_vendor() -> Result<String, GfxError> {
-        let modules = Module::all().map_err(|err| GfxError::Read("get_vendor".into(), err))?;
-        let vendor = if modules
-            .iter()
-            .any(|module| module.name == "nouveau" || module.name == "nvidia")
-        {
-            let mode = match Self::get_prime_discrete() {
-                Ok(m) => m,
-                Err(_) => "nvidia".to_string(),
-            };
-
-            if mode == "on-demand" {
-                "hybrid".to_string()
-            } else if mode == "off" {
-                "compute".to_string()
-            } else {
-                "nvidia".to_string()
-            }
-        } else {
-            "integrated".to_string()
-        };
-
-        Ok(vendor)
-    }
-
-    pub fn is_switching_prime_modes(vendor: &GfxVendors) -> Result<bool, GfxError> {
-        let prev_mode = GfxVendors::from_str(&Self::get_vendor()?)?;
-        let x = (prev_mode == GfxVendors::Hybrid || prev_mode == GfxVendors::Nvidia)
-            && (*vendor == GfxVendors::Hybrid || *vendor == GfxVendors::Nvidia);
-        Ok(x)
-    }
-
-    /// Write out config files if required, enable/disable relevant services, and update the ramdisk
-    pub fn set(&mut self, vendor: GfxVendors) -> Result<String, GfxError> {
-        //self.switchable_or_fail()?;
-
-        let mode = if vendor == GfxVendors::Hybrid {
-            "on-demand\n"
-        } else if vendor == GfxVendors::Nvidia {
-            "on\n"
-        } else {
-            // Integrated or Compute
-            "off\n"
-        };
-
-        info!("Setting {} to {}", PRIME_DISCRETE_PATH, mode);
-        Self::set_prime_discrete(mode)?;
-
-        // Switching from hybrid to/from nvidia shouldn't require a ramdisk update
-        // or a reboot.
-        let switching_prime_modes = Self::is_switching_prime_modes(&vendor)?;
-
-        {
-            info!("Creating {}", MODPROBE_PATH);
-
-            let mut file = std::fs::OpenOptions::new()
-                .create(true)
-                .truncate(true)
-                .write(true)
-                .open(MODPROBE_PATH)
-                .map_err(|err| GfxError::Path(MODPROBE_PATH.into(), err))?;
-
-            let text = if vendor == GfxVendors::Hybrid {
-                MODPROBE_HYBRID
-            } else if vendor == GfxVendors::Compute {
-                MODPROBE_COMPUTE
-            } else if vendor == GfxVendors::Nvidia {
-                MODPROBE_NVIDIA
-            } else {
-                MODPROBE_INTEGRATED
-            };
-
-            file.write_all(text)
-                .and_then(|_| file.sync_all())
-                .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
-        }
-
-        info!("Creating {}", PRIMARY_GPU_XORG_PATH);
-
-        // begin section for non-separated Nvidia xorg modules
-        // eg, not put in their own directory
-        let mut file = std::fs::OpenOptions::new()
-            .create(true)
-            .truncate(true)
-            .write(true)
-            .open(PRIMARY_GPU_XORG_PATH)
-            .map_err(|err| GfxError::Write(PRIMARY_GPU_XORG_PATH.into(), err))?;
-
-        let text = if vendor == GfxVendors::Nvidia {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_NVIDIA, PRIMARY_GPU_END].concat()
-        } else {
-            [PRIMARY_GPU_BEGIN, PRIMARY_GPU_END].concat()
-        };
-
-        file.write_all(&text)
-            .and_then(|_| file.sync_all())
-            .map_err(|err| GfxError::Write(MODPROBE_PATH.into(), err))?;
-
-        let action = if vendor == GfxVendors::Nvidia {
-            info!("Enabling nvidia-fallback.service");
-            "enable"
-        } else {
-            info!("Disabling nvidia-fallback.service");
-            "disable"
-        };
-
-        let status = Command::new("systemctl")
-            .arg(action)
-            .arg("nvidia-fallback.service")
-            .status()
-            .map_err(|err| GfxError::Command("systemctl".into(), err))?;
-
-        if !status.success() {
-            // Error is ignored in case this service is removed
-            warn!(
-                "systemctl: {} (ignore warning if service does not exist!)",
-                status
-            );
-        }
-
-        let mut required_action = GfxCtrlAction::None;
-        if !switching_prime_modes {
-            info!("Updating initramfs");
-            if let Some(cmd) = self.initfs_cmd.as_mut() {
-                let status = cmd
-                    .status()
-                    .map_err(|err| GfxError::Write(format!("{:?}", cmd), err))?;
-                if !status.success() {
-                    error!("Ram disk update failed");
-                } else {
-                    info!("Successfully updated iniramfs");
-                }
-            }
-            required_action = GfxCtrlAction::Reboot;
-        } else if switching_prime_modes {
-            required_action = GfxCtrlAction::RestartX;
-        }
-
-        Ok(required_action.into())
-    }
-
-    pub fn get_power(&self) -> Option<bool> {
-        if self.can_switch() {
-            return Some(self.nvidia.iter().any(GraphicsDevice::exists));
-        }
-        None
-    }
-
-    fn set_power(&self, power: bool) -> Result<(), GfxError> {
-        // self.switchable_or_fail()?;
-
-        if power {
-            info!("Enabling graphics power");
-            self.bus
-                .rescan()
-                .map_err(|err| GfxError::Bus("bus rescan error".into(), err))?;
-        } else {
-            info!("Disabling graphics power");
-
-            // Unbind NVIDIA graphics devices and their functions
-            let unbinds = self.nvidia.iter().map(|dev| dev.unbind());
-
-            // Remove NVIDIA graphics devices and their functions
-            let removes = self.nvidia.iter().map(|dev| dev.remove());
-
-            Result::from_iter(unbinds.chain(removes))
-                .map_err(|err| GfxError::Command("device unbind error".into(), err))?;
-        }
-
-        Ok(())
-    }
-
-    fn auto_power(&self) -> Result<(), GfxError> {
-        let vendor = CtrlGraphics::get_vendor()?;
-        self.set_power(vendor != "integrated")
-    }
-}

ctrl-gfx/src/error.rs

@@ -1,30 +0,0 @@
-use std::error;
-use std::fmt;
-
-#[derive(Debug)]
-pub enum GfxError {
-    ParseVendor,
-    Path(String, std::io::Error),
-    Read(String, std::io::Error),
-    Write(String, std::io::Error),
-    Module(String, std::io::Error),
-    Bus(String, std::io::Error),
-    Command(String, std::io::Error),
-}
-
-impl fmt::Display for GfxError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            GfxError::ParseVendor => write!(f, "Could not parse vendor name"),
-            GfxError::Path(path, error) => write!(f, "Path {}: {}", path, error),
-            GfxError::Read(path, error) => write!(f, "Read {}: {}", path, error),
-            GfxError::Write(path, error) => write!(f, "Write {}: {}", path, error),
-            GfxError::Module(func, error) => write!(f, "Module error: {}: {}", func, error),
-            GfxError::Bus(func, error) => write!(f, "Bus error: {}: {}", func, error),
-            GfxError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
-        }
-    }
-}
-
-impl error::Error for GfxError {}

ctrl-gfx/src/lib.rs

@@ -1,58 +0,0 @@
-pub mod vendors;
-
-pub mod error;
-
-pub mod ctrl_gfx;
-
-pub mod system;
-
-const PRIME_DISCRETE_PATH: &str = "/etc/prime-discrete";
-const MODPROBE_PATH: &str = "/etc/modprobe.d/asusd.conf";
-const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
-const DRACUT_PATH: &str = "/usr/bin/dracut";
-
-static MODPROBE_NVIDIA: &[u8] = MODPROBE_HYBRID;
-
-static MODPROBE_HYBRID: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-alias i2c_nvidia_gpu off
-options nvidia NVreg_DynamicPowerManagement=0x02
-options nvidia-drm modeset=1
-"#;
-
-static MODPROBE_COMPUTE: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-alias i2c_nvidia_gpu off
-options nvidia NVreg_DynamicPowerManagement=0x02
-options nvidia-drm modeset=0
-"#;
-
-static MODPROBE_INTEGRATED: &[u8] = br#"# Automatically generated by asusd
-blacklist i2c_nvidia_gpu
-blacklist nouveau
-blacklist nvidia
-blacklist nvidia-drm
-blacklist nvidia-modeset
-alias i2c_nvidia_gpu off
-alias nouveau off
-alias nvidia off
-alias nvidia-drm off
-alias nvidia-modeset off
-"#;
-
-const PRIMARY_GPU_XORG_PATH: &str = "/etc/X11/xorg.conf.d/90-nvidia-primary.conf";
-
-static PRIMARY_GPU_BEGIN: &[u8] = br#"# Automatically generated by asusd
-Section "OutputClass"
-    Identifier "nvidia"
-    MatchDriver "nvidia-drm"
-    Driver "nvidia"
-    Option "TripleBuffer" "true"
-    Option "AllowEmptyInitialConfiguration"
-    Option "AllowExternalGpus""#;
-
-static PRIMARY_GPU_NVIDIA: &[u8] = br#"
-    Option "PrimaryGPU" "true""#;
-
-static PRIMARY_GPU_END: &[u8] = br#"
-EndSection"#;

ctrl-gfx/src/system.rs

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

ctrl-gfx/src/vendors.rs

@@ -1,85 +0,0 @@
-#[derive(Debug, PartialEq, Clone)]
-pub enum GfxVendors {
-    Nvidia,
-    Integrated,
-    Compute,
-    Hybrid,
-}
-
-use crate::error::GfxError;
-use std::str::FromStr;
-
-impl FromStr for GfxVendors {
-    type Err = GfxError;
-
-    fn from_str(s: &str) -> Result<Self, GfxError> {
-        match s.to_lowercase().as_str() {
-            "nvidia" => Ok(GfxVendors::Nvidia),
-            "hybrid" => Ok(GfxVendors::Hybrid),
-            "compute" => Ok(GfxVendors::Compute),
-            "integrated" => Ok(GfxVendors::Integrated),
-            "nvidia\n" => Ok(GfxVendors::Nvidia),
-            "hybrid\n" => Ok(GfxVendors::Hybrid),
-            "compute\n" => Ok(GfxVendors::Compute),
-            "integrated\n" => Ok(GfxVendors::Integrated),
-            _ => Err(GfxError::ParseVendor),
-        }
-    }
-}
-
-impl From<&GfxVendors> for &str {
-    fn from(mode: &GfxVendors) -> Self {
-        match mode {
-            GfxVendors::Nvidia => "nvidia",
-            GfxVendors::Hybrid => "hybrid",
-            GfxVendors::Compute => "compute",
-            GfxVendors::Integrated => "integrated",
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum GfxCtrlAction {
-    Reboot,
-    RestartX,
-    None,
-}
-
-impl FromStr for GfxCtrlAction {
-    type Err = GfxError;
-
-    fn from_str(s: &str) -> Result<Self, GfxError> {
-        match s.to_lowercase().as_str() {
-            "reboot" => Ok(GfxCtrlAction::Reboot),
-            "restartx" => Ok(GfxCtrlAction::RestartX),
-            "none" => Ok(GfxCtrlAction::None),
-            _ => Err(GfxError::ParseVendor),
-        }
-    }
-}
-
-impl From<&GfxCtrlAction> for &str {
-    fn from(mode: &GfxCtrlAction) -> Self {
-        match mode {
-            GfxCtrlAction::Reboot => "reboot",
-            GfxCtrlAction::RestartX => "restartx",
-            GfxCtrlAction::None => "none",
-        }
-    }
-}
-
-impl From<&GfxCtrlAction> for String {
-    fn from(mode: &GfxCtrlAction) -> Self {
-        match mode {
-            GfxCtrlAction::Reboot => "reboot".into(),
-            GfxCtrlAction::RestartX => "restartx".into(),
-            GfxCtrlAction::None => "none".into(),
-        }
-    }
-}
-
-impl From<GfxCtrlAction> for String {
-    fn from(mode: GfxCtrlAction) -> Self {
-        (&mode).into()
-    }
-}

daemon-user/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "daemon-user"
+license = "MPL-2.0"
+version.workspace = true
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2021"
+description = "Usermode daemon for user settings, anime, per-key lighting"
+
+[lib]
+name = "rog_user"
+path = "src/lib.rs"
+
+[[bin]]
+name = "asusd-user"
+path = "src/daemon.rs"
+
+[dependencies]
+dirs.workspace = true
+smol.workspace = true
+
+# serialisation
+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_platform = { path = "../rog-platform" }
+config-traits = { path = "../config-traits" }
+
+zbus.workspace = true
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

daemon-user/README.md

@@ -0,0 +1,14 @@
+# daemon-user
+
+This crate is for the binary of `asusd-user` and its helper lib.
+
+The purpose of `asusd-user` is to run in userland and provide the user + third-party apps an interface for such things as creating AniMe sequences (and more in future, see todo list).
+
+`asusd-user` should try to be as simple as possible while allowing a decent degree of control.
+
+## TODO
+
+- [ ] CLI for basic settings/interaction
+- [ ] RGB keyboard per-key programs
+- [ ] User profiles (fan, cpu etc). These would be replacing the system-daemon profiles only when the user is active, otherwise system-daemon defaults to system settings.
+- [ ] Audio EQ visualiser - for use with anime + keyboard lighting

daemon-user/src/config.rs

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

daemon-user/src/ctrl_anime.rs

@@ -0,0 +1,373 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use config_traits::StdConfig;
+use rog_anime::error::AnimeError;
+use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
+use rog_dbus::RogDbusClientBlocking;
+use serde_derive::{Deserialize, Serialize};
+use zbus::dbus_interface;
+use zbus::zvariant::{ObjectPath, Type};
+
+use crate::config::ConfigAnime;
+use crate::error::Error;
+
+#[derive(Debug, Clone, Deserialize, Serialize, Type)]
+pub struct Timer {
+    type_of: TimeType,
+    /// If time type is Timer then this is milliseonds, otherwise it is
+    /// animation loop count
+    count: u64,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
+    fade_in: Option<u64>,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image out for
+    fade_out: Option<u64>,
+}
+
+impl From<Timer> for AnimTime {
+    fn from(time: Timer) -> Self {
+        match time.type_of {
+            TimeType::Timer => {
+                if time.fade_in.is_some() || time.fade_out.is_some() {
+                    let fade_in = time
+                        .fade_in
+                        .map_or(Duration::from_secs(0), Duration::from_millis);
+                    let fade_out = time
+                        .fade_out
+                        .map_or(Duration::from_secs(0), Duration::from_millis);
+                    let show_for = if time.count != 0 {
+                        Some(Duration::from_millis(time.count))
+                    } else {
+                        None
+                    };
+                    AnimTime::Fade(Fade::new(fade_in, show_for, fade_out))
+                } else {
+                    AnimTime::Time(Duration::from_millis(time.count))
+                }
+            }
+            TimeType::Count => AnimTime::Count(time.count as u32),
+            TimeType::Infinite => AnimTime::Infinite,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, Type)]
+pub enum TimeType {
+    Timer,
+    Count,
+    Infinite,
+}
+
+/// The inner object exists to allow the zbus proxy to share it with a runner
+/// thread and a zbus server behind `Arc<Mutex<T>>`
+pub struct CtrlAnimeInner<'a> {
+    sequences: Sequences,
+    client: RogDbusClientBlocking<'a>,
+    do_early_return: Arc<AtomicBool>,
+}
+
+impl<'a> CtrlAnimeInner<'static> {
+    pub fn new(
+        sequences: Sequences,
+        client: RogDbusClientBlocking<'static>,
+        do_early_return: Arc<AtomicBool>,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            sequences,
+            client,
+            do_early_return,
+        })
+    }
+
+    /// To be called on each main loop iteration to pump out commands to the
+    /// anime
+    pub fn run(&'a self) -> Result<(), Error> {
+        if self.do_early_return.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
+        for action in self.sequences.iter() {
+            match action {
+                ActionData::Animation(frames) => {
+                    rog_anime::run_animation(frames, &|output| {
+                        if self.do_early_return.load(Ordering::Acquire) {
+                            return Ok(true); // Do safe exit
+                        }
+                        self.client
+                            .proxies()
+                            .anime()
+                            .write(output)
+                            .map_err(|e| AnimeError::Dbus(format!("{}", e)))
+                            .map(|_| false)
+                    });
+                }
+                ActionData::Image(image) => {
+                    self.client
+                        .proxies()
+                        .anime()
+                        .write(image.as_ref().clone())
+                        .ok();
+                }
+                ActionData::Pause(duration) => {
+                    let start = Instant::now();
+                    'pause: loop {
+                        if self.do_early_return.load(Ordering::SeqCst) {
+                            return Ok(());
+                        }
+                        if Instant::now().duration_since(start) > *duration {
+                            break 'pause;
+                        }
+                        sleep(Duration::from_millis(1));
+                    }
+                }
+                ActionData::AudioEq
+                | ActionData::SystemInfo
+                | ActionData::TimeDate
+                | ActionData::Matrix => {}
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub struct CtrlAnime<'a> {
+    config: Arc<Mutex<ConfigAnime>>,
+    client: RogDbusClientBlocking<'a>,
+    inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
+    /// Must be the same Atomic as in CtrlAnimeInner
+    inner_early_return: Arc<AtomicBool>,
+}
+
+impl CtrlAnime<'static> {
+    pub fn new(
+        config: Arc<Mutex<ConfigAnime>>,
+        inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
+        client: RogDbusClientBlocking<'static>,
+        inner_early_return: Arc<AtomicBool>,
+    ) -> Result<Self, Error> {
+        Ok(CtrlAnime {
+            config,
+            client,
+            inner,
+            inner_early_return,
+        })
+    }
+
+    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
+            })
+            .ok();
+    }
+}
+
+// The pattern for a zbus method is:
+// - Get config lock if required
+// - Set inner_early_return to stop the inner run loop temporarily
+// - Do actions
+// - Write config if required
+// - Unset inner_early_return
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnime<'static> {
+    pub fn insert_asus_gif(
+        &mut self,
+        index: u32,
+        file: &str,
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = time.into();
+            let file = Path::new(&file);
+            let action = ActionLoader::AsusAnimation {
+                file: file.into(),
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn insert_image_gif(
+        &mut self,
+        index: u32,
+        file: &str,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = time.into();
+            let file = Path::new(&file);
+            let translation = Vec2::new(xy.0, xy.1);
+            let action = ActionLoader::ImageAnimation {
+                file: file.into(),
+                scale,
+                angle,
+                translation,
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn insert_image(
+        &mut self,
+        index: u32,
+        file: &str,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let file = Path::new(&file);
+            let time = time.into();
+            let action = ActionLoader::Image {
+                file: file.into(),
+                scale,
+                angle,
+                translation: Vec2::new(xy.0, xy.1),
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn insert_pause(&mut self, index: u32, millis: u64) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let action = ActionLoader::Pause(Duration::from_millis(millis));
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn remove_item(&mut self, index: u32) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.remove_item(index as usize);
+            }
+            if (index as usize) < config.anime.len() {
+                config.anime.remove(index as usize);
+            }
+            config.write();
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    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).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).ok();
+        }
+        Ok(())
+    }
+}

daemon-user/src/daemon.rs

@@ -0,0 +1,116 @@
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::usb::get_anime_type;
+use rog_aura::aura_detection::LaptopLedData;
+use rog_aura::layouts::KeyLayout;
+use rog_dbus::RogDbusClientBlocking;
+use rog_user::config::*;
+use rog_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
+use rog_user::DBUS_NAME;
+use smol::Executor;
+use zbus::Connection;
+
+#[cfg(not(feature = "local_data"))]
+const DATA_DIR: &str = "/usr/share/rog-gui/";
+#[cfg(feature = "local_data")]
+const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .init();
+
+    println!("  user daemon v{}", rog_user::VERSION);
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
+
+    let (client, _) = RogDbusClientBlocking::new()?;
+    let supported = client.proxies().supported().supported_functions()?;
+
+    let config = ConfigBase::new().load();
+
+    let executor = Executor::new();
+
+    let early_return = Arc::new(AtomicBool::new(false));
+    // Set up the anime data and run loop/thread
+    if supported.anime_ctrl.0 {
+        if let Some(cfg) = config.active_anime {
+            let anime_type = get_anime_type()?;
+            let anime_config = ConfigAnime::new().set_name(cfg).load();
+            let anime = anime_config.create(anime_type)?;
+            let anime_config = Arc::new(Mutex::new(anime_config));
+
+            executor
+                .spawn(async move {
+                    // Create server
+                    let mut connection = Connection::session().await.unwrap();
+                    connection.request_name(DBUS_NAME).await.unwrap();
+
+                    // Inner behind mutex required for thread safety
+                    let inner = Arc::new(Mutex::new(
+                        CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let (client, _) = RogDbusClientBlocking::new().unwrap();
+                    let anime_control =
+                        CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                    anime_control.add_to_server(&mut connection).await;
+                    loop {
+                        if let Ok(inner) = inner.clone().try_lock() {
+                            inner.run().ok();
+                        }
+                    }
+                })
+                .detach();
+        }
+    }
+
+    // if supported.keyboard_led.per_key_led_mode {
+    if let Some(cfg) = config.active_aura {
+        let mut aura_config = ConfigAura::new().set_name(cfg).load();
+        // let baord_name = std::fs::read_to_string(BOARD_NAME)?;
+
+        let led_support = LaptopLedData::get_data();
+
+        let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
+            .map_err(|e| {
+                println!("{BOARD_NAME}, {e}");
+            })
+            .unwrap_or_else(|_| KeyLayout::default_layout());
+
+        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()
+                        .direct_addressing_raw(packets)
+                        .unwrap();
+                    std::thread::sleep(std::time::Duration::from_millis(33));
+                }
+            })
+            .detach();
+    }
+    // }
+
+    loop {
+        smol::block_on(executor.tick());
+    }
+}

daemon-user/src/error.rs

@@ -0,0 +1,45 @@
+use std::fmt;
+
+use rog_anime::error::AnimeError;
+
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+    ConfigLoadFail,
+    ConfigLockFail,
+    XdgVars,
+    Anime(AnimeError),
+}
+
+impl fmt::Display for Error {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Io(err) => write!(f, "Failed to open: {}", err),
+            Error::ConfigLoadFail => write!(f, "Failed to load user config"),
+            Error::ConfigLockFail => write!(f, "Failed to lock user config"),
+            Error::XdgVars => write!(f, "XDG environment vars appear unset"),
+            Error::Anime(err) => write!(f, "Anime error: {}", err),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+impl From<AnimeError> for Error {
+    fn from(err: AnimeError) -> Self {
+        Error::Anime(err)
+    }
+}
+
+impl From<Error> for zbus::fdo::Error {
+    fn from(err: Error) -> Self {
+        zbus::fdo::Error::Failed(format!("Anime zbus error: {}", err))
+    }
+}

daemon-user/src/lib.rs

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

daemon-user/src/zbus_anime.rs

@@ -0,0 +1,70 @@
+//! # `DBus` interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from `DBus` introspection
+//! data. Source: `Interface '/org/asuslinux/Anime' from service
+//! 'org.asuslinux.Daemon' on session bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This `DBus` object implements
+//! [standard `DBus` interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+#![allow(clippy::too_many_arguments)]
+
+use zbus::dbus_proxy;
+
+#[dbus_proxy(interface = "org.asuslinux.Daemon")]
+trait Daemon {
+    /// InsertAsusGif method
+    fn insert_asus_gif(
+        &self,
+        index: u32,
+        file: &str,
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImage method
+    fn insert_image(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImageGif method
+    fn insert_image_gif(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertPause method
+    fn insert_pause(&self, index: u32, millis: u64) -> zbus::Result<String>;
+
+    /// RemoveItem method
+    fn remove_item(&self, index: u32) -> zbus::Result<String>;
+
+    /// SetState method
+    fn set_state(&self, on: bool) -> zbus::Result<()>;
+}

daemon/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "daemon"
+license = "MPL-2.0"
+version.workspace = true
+readme = "README.md"
+authors = ["Luke <luke@ljones.dev>"]
+repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
+homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
+description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
+edition = "2021"
+
+[lib]
+name = "daemon"
+path = "src/lib.rs"
+
+[[bin]]
+name = "asusd"
+path = "src/daemon.rs"
+
+[dependencies]
+config-traits = { path = "../config-traits" }
+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" }
+
+async-trait.workspace = true
+tokio.workspace = true
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+zbus.workspace = true
+logind-zbus.workspace = true
+
+# serialisation
+serde.workspace = true
+serde_derive.workspace = true
+
+# Device control
+sysfs-class.workspace = true # used for backlight control and baord ID
+
+concat-idents.workspace = true
+
+systemd-zbus = "*"
+
+[dev-dependencies]
+cargo-husky.workspace = true

daemon/src/config.rs

@@ -0,0 +1,77 @@
+use config_traits::{StdConfig, StdConfigLoad2};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+#[derive(Deserialize, Serialize, Default, Debug)]
+pub struct Config {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            bat_charge_limit: 100,
+            panel_od: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad2<Config455, Config458> for Config {}
+
+#[derive(Deserialize, Serialize, Default)]
+#[serde(default)]
+pub struct Config455 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+}
+
+impl From<Config455> for Config {
+    fn from(c: Config455) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct Config458 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config458> for Config {
+    fn from(c: Config458) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+        }
+    }
+}

daemon/src/ctrl_anime/config.rs

@@ -0,0 +1,254 @@
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad2};
+use rog_anime::error::AnimeError;
+use rog_anime::{ActionData, ActionLoader, AnimTime, AnimeType, Fade, Vec2};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "anime.ron";
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV341 {
+    pub system: Option<ActionLoader>,
+    pub boot: Option<ActionLoader>,
+    pub suspend: Option<ActionLoader>,
+    pub shutdown: Option<ActionLoader>,
+}
+
+impl From<AnimeConfigV341> for AnimeConfig {
+    fn from(c: AnimeConfigV341) -> AnimeConfig {
+        AnimeConfig {
+            system: if let Some(ani) = c.system {
+                vec![ani]
+            } else {
+                vec![]
+            },
+            boot: if let Some(ani) = c.boot {
+                vec![ani]
+            } else {
+                vec![]
+            },
+            wake: if let Some(ani) = c.suspend {
+                vec![ani]
+            } else {
+                vec![]
+            },
+            shutdown: if let Some(ani) = c.shutdown.clone() {
+                vec![ani]
+            } else {
+                vec![]
+            },
+            sleep: if let Some(ani) = c.shutdown.clone() {
+                vec![ani]
+            } else {
+                vec![]
+            },
+            brightness: 1.0,
+            awake_enabled: true,
+            boot_anim_enabled: true,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV352 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+}
+
+impl From<AnimeConfigV352> for AnimeConfig {
+    fn from(c: AnimeConfigV352) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            sleep: c.shutdown.clone(),
+            shutdown: c.shutdown,
+            brightness: 1.0,
+            awake_enabled: true,
+            boot_anim_enabled: true,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV460 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+}
+
+impl From<AnimeConfigV460> for AnimeConfig {
+    fn from(c: AnimeConfigV460) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            sleep: c.sleep,
+            shutdown: c.shutdown,
+            brightness: 1.0,
+            awake_enabled: true,
+            boot_anim_enabled: true,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct AnimeConfigCached {
+    pub system: Vec<ActionData>,
+    pub boot: Vec<ActionData>,
+    pub wake: Vec<ActionData>,
+    pub sleep: Vec<ActionData>,
+    pub shutdown: Vec<ActionData>,
+}
+
+impl AnimeConfigCached {
+    pub fn init_from_config(
+        &mut self,
+        config: &AnimeConfig,
+        anime_type: AnimeType,
+    ) -> Result<(), AnimeError> {
+        let mut sys = Vec::with_capacity(config.system.len());
+        for ani in &config.system {
+            sys.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.system = sys;
+
+        let mut boot = Vec::with_capacity(config.boot.len());
+        for ani in &config.boot {
+            boot.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.boot = boot;
+
+        let mut wake = Vec::with_capacity(config.wake.len());
+        for ani in &config.wake {
+            wake.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.wake = wake;
+
+        let mut sleep = Vec::with_capacity(config.sleep.len());
+        for ani in &config.sleep {
+            sleep.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.sleep = sleep;
+
+        let mut shutdown = Vec::with_capacity(config.shutdown.len());
+        for ani in &config.shutdown {
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.shutdown = shutdown;
+        Ok(())
+    }
+}
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AnimeConfig {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+    pub awake_enabled: bool,
+    pub boot_anim_enabled: bool,
+}
+
+impl Default for AnimeConfig {
+    fn default() -> Self {
+        AnimeConfig {
+            system: Vec::new(),
+            boot: Vec::new(),
+            wake: Vec::new(),
+            sleep: Vec::new(),
+            shutdown: Vec::new(),
+            brightness: 1.0,
+            awake_enabled: true,
+            boot_anim_enabled: true,
+        }
+    }
+}
+
+impl StdConfig for AnimeConfig {
+    fn new() -> Self {
+        Self::create_default()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad2<AnimeConfigV341, AnimeConfigV352> for AnimeConfig {}
+
+impl AnimeConfig {
+    // fn clamp_config_brightness(mut config: &mut AnimeConfig) {
+    //     if config.brightness < 0.0 || config.brightness > 1.0 {
+    //         warn!(
+    //             "Clamped brightness to [0.0 ; 1.0], was {}",
+    //             config.brightness
+    //         );
+    //         config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
+    //     }
+    // }
+
+    fn create_default() -> Self {
+        // create a default config here
+        AnimeConfig {
+            system: vec![],
+            boot: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            wake: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            sleep: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                scale: 0.9,
+                angle: 0.0,
+                translation: Vec2::new(3.0, 2.0),
+                brightness: 1.0,
+                time: AnimTime::Infinite,
+            }],
+            shutdown: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                scale: 0.9,
+                angle: 0.0,
+                translation: Vec2::new(3.0, 2.0),
+                brightness: 1.0,
+                time: AnimTime::Infinite,
+            }],
+            brightness: 1.0,
+            awake_enabled: true,
+            boot_anim_enabled: true,
+        }
+    }
+}

daemon/src/ctrl_anime/mod.rs

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

daemon/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,212 @@
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::warn;
+use rog_anime::usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on};
+use rog_anime::{AnimeDataBuffer, AnimePowerStates};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use super::CtrlAnime;
+use crate::error::RogError;
+
+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 inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            move || {
+                // on_sleep
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    CtrlAnime::run_thread(inner1.clone(), lock.cache.sleep.clone(), true);
+                }
+            },
+            move || {
+                // on_wake
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    CtrlAnime::run_thread(inner2.clone(), lock.cache.wake.clone(), true);
+                }
+            },
+            move || {
+                // on_shutdown
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    CtrlAnime::run_thread(inner3.clone(), lock.cache.shutdown.clone(), true);
+                }
+            },
+            move || {
+                // on_boot
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    CtrlAnime::run_thread(inner4.clone(), lock.cache.boot.clone(), true);
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlAnimeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
+            lock.node
+                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+            lock.node
+                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+
+            let action = lock.cache.boot.clone();
+            CtrlAnime::run_thread(self.0.clone(), action, true);
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_aura/config.rs

@@ -0,0 +1,353 @@
+use std::collections::{BTreeMap, HashSet};
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_aura::aura_detection::LaptopLedData;
+use rog_aura::usb::{AuraDevRog1, AuraDevRog2, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "aura.ron";
+
+/// 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>),
+    AuraDevRog1(HashSet<AuraDevRog1>),
+    AuraDevRog2(HashSet<AuraDevRog2>),
+}
+
+impl AuraPowerConfig {
+    /// Invalid for TUF laptops
+    pub fn to_bytes(control: &Self) -> [u8; 3] {
+        match control {
+            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
+            AuraPowerConfig::AuraDevRog1(c) => {
+                let c: Vec<AuraDevRog1> = c.iter().copied().collect();
+                AuraDevRog1::to_bytes(&c)
+            }
+            AuraPowerConfig::AuraDevRog2(c) => {
+                let c: Vec<AuraDevRog2> = c.iter().copied().collect();
+                AuraDevRog2::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::AuraDevRog1(c) = control {
+            return Some([
+                true,
+                c.contains(&AuraDevRog1::Boot),
+                c.contains(&AuraDevRog1::Awake),
+                c.contains(&AuraDevRog1::Sleep),
+                c.contains(&AuraDevRog1::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: AuraDevRog1, on: bool) {
+        if let Self::AuraDevRog1(p) = self {
+            if on {
+                p.insert(power);
+            } else {
+                p.remove(&power);
+            }
+        }
+    }
+
+    pub fn set_0x19b6(&mut self, power: AuraDevRog2, on: bool) {
+        if let Self::AuraDevRog2(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::AuraDevRog1(d) => AuraPowerDev {
+                tuf: vec![],
+                x1866: d.iter().copied().collect(),
+                x19b6: vec![],
+            },
+            AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev {
+                tuf: vec![],
+                x1866: vec![],
+                x19b6: d.iter().copied().collect(),
+            },
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, Clone)]
+// #[serde(default)]
+pub struct AuraConfig {
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
+    pub multizone_on: bool,
+    pub enabled: AuraPowerConfig,
+}
+
+impl StdConfig for AuraConfig {
+    fn new() -> Self {
+        // Self::create_default(AuraDevice::X19b6, &LaptopLedData::get_data())
+        panic!("AuraConfig::new() should not be used, use AuraConfig::create_default() instead");
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for AuraConfig {}
+
+impl AuraConfig {
+    pub fn create_default(prod_id: AuraDevice, support_data: &LaptopLedData) -> Self {
+        // create a default config here
+        let enabled = if prod_id == AuraDevice::X19b6 {
+            AuraPowerConfig::AuraDevRog2(HashSet::from([
+                AuraDevRog2::BootLogo,
+                AuraDevRog2::BootKeyb,
+                AuraDevRog2::SleepLogo,
+                AuraDevRog2::SleepKeyb,
+                AuraDevRog2::AwakeLogo,
+                AuraDevRog2::AwakeKeyb,
+                AuraDevRog2::ShutdownLogo,
+                AuraDevRog2::ShutdownKeyb,
+                AuraDevRog2::BootBar,
+                AuraDevRog2::AwakeBar,
+                AuraDevRog2::SleepBar,
+                AuraDevRog2::ShutdownBar,
+            ]))
+        } else if prod_id == AuraDevice::Tuf {
+            AuraPowerConfig::AuraDevTuf(HashSet::from([
+                AuraDevTuf::Awake,
+                AuraDevTuf::Boot,
+                AuraDevTuf::Sleep,
+                AuraDevTuf::Keyboard,
+            ]))
+        } else {
+            AuraPowerConfig::AuraDevRog1(HashSet::from([
+                AuraDevRog1::Awake,
+                AuraDevRog1::Boot,
+                AuraDevRog1::Sleep,
+                AuraDevRog1::Keyboard,
+                AuraDevRog1::Lightbar,
+            ]))
+        };
+        let mut config = AuraConfig {
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+            multizone_on: false,
+            enabled,
+        };
+
+        for n in &support_data.basic_modes {
+            config
+                .builtins
+                .insert(*n, AuraEffect::default_with_mode(*n));
+
+            if !support_data.basic_zones.is_empty() {
+                let mut default = vec![];
+                for (i, tmp) in support_data.basic_zones.iter().enumerate() {
+                    default.push(AuraEffect {
+                        mode: *n,
+                        zone: *tmp,
+                        colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                        colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                        speed: Speed::Med,
+                        direction: Direction::Left,
+                    });
+                }
+                if let Some(m) = config.multizone.as_mut() {
+                    m.insert(*n, default);
+                } else {
+                    let mut tmp = BTreeMap::new();
+                    tmp.insert(*n, default);
+                    config.multizone = Some(tmp);
+                }
+            }
+        }
+        config
+    }
+
+    /// Set the mode data, current mode, and if multizone enabled.
+    ///
+    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct
+    /// store.
+    pub fn set_builtin(&mut self, effect: AuraEffect) {
+        self.current_mode = effect.mode;
+        if effect.zone() == AuraZone::None {
+            self.builtins.insert(*effect.mode(), effect);
+            self.multizone_on = false;
+        } else {
+            if let Some(multi) = self.multizone.as_mut() {
+                if let Some(fx) = multi.get_mut(effect.mode()) {
+                    for fx in fx.iter_mut() {
+                        if fx.zone == effect.zone {
+                            *fx = effect;
+                            return;
+                        }
+                    }
+                    fx.push(effect);
+                } else {
+                    multi.insert(*effect.mode(), vec![effect]);
+                }
+            } else {
+                let mut tmp = BTreeMap::new();
+                tmp.insert(*effect.mode(), vec![effect]);
+                self.multizone = Some(tmp);
+            }
+            self.multizone_on = true;
+        }
+    }
+
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
+        if let Some(multi) = &self.multizone {
+            return multi.get(&aura_type).map(|v| v.as_slice());
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::aura_detection::LaptopLedData;
+    use rog_aura::usb::AuraDevice;
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+
+    use super::AuraConfig;
+
+    #[test]
+    fn set_multizone_4key_config() {
+        let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
+
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0x00, 0xff),
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 0xff),
+            zone: AuraZone::Key2,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0xff, 0x00),
+            zone: AuraZone::Key3,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 0x00),
+            zone: AuraZone::Key4,
+            ..Default::default()
+        };
+        let effect_clone = effect.clone();
+        config.set_builtin(effect);
+        // This should replace existing
+        config.set_builtin(effect_clone);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 4);
+        assert_eq!(sta[0].colour1, Colour(0xff, 0x00, 0xff));
+        assert_eq!(sta[1].colour1, Colour(0x00, 0xff, 0xff));
+        assert_eq!(sta[2].colour1, Colour(0xff, 0xff, 0x00));
+        assert_eq!(sta[3].colour1, Colour(0x00, 0xff, 0x00));
+    }
+
+    #[test]
+    fn set_multizone_multimode_config() {
+        let mut config = AuraConfig::create_default(AuraDevice::X19b6, &LaptopLedData::default());
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key2,
+            mode: AuraModeNum::Breathe,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key3,
+            mode: AuraModeNum::Comet,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key4,
+            mode: AuraModeNum::Pulse,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Breathe).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Comet).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Pulse).unwrap();
+        assert_eq!(sta.len(), 1);
+    }
+}

daemon/src/ctrl_aura/controller.rs

@@ -0,0 +1,549 @@
+use std::collections::BTreeMap;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{info, warn};
+use rog_aura::advanced::{LedUsbPackets, UsbPackets};
+use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
+use rog_aura::usb::{AuraDevice, LED_APPLY, LED_SET};
+use rog_aura::{AuraEffect, AuraZone, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardLed;
+use rog_platform::supported::LedSupportedFunctions;
+
+use super::config::{AuraConfig, AuraPowerConfig};
+use crate::error::RogError;
+use crate::GetSupported;
+
+impl GetSupported for CtrlKbdLed {
+    type A = LedSupportedFunctions;
+
+    fn get_supported() -> Self::A {
+        // let mode = <&str>::from(&<AuraModes>::from(*mode));
+        let laptop = LaptopLedData::get_data();
+        let stock_led_modes = laptop.basic_modes;
+        let multizone_led_mode = laptop.basic_zones;
+        let advanced_type = laptop.advanced_type;
+
+        let mut prod_id = AuraDevice::Unknown;
+        for prod in ASUS_KEYBOARD_DEVICES {
+            if HidRaw::new(prod.into()).is_ok() {
+                prod_id = prod;
+                break;
+            }
+        }
+
+        let rgb = KeyboardLed::new();
+        if let Ok(p) = rgb.as_ref() {
+            if p.has_kbd_rgb_mode() {
+                prod_id = AuraDevice::Tuf;
+            }
+        }
+
+        LedSupportedFunctions {
+            dev_id: prod_id,
+            brightness: rgb.is_ok(),
+            basic_modes: stock_led_modes,
+            basic_zones: multizone_led_mode,
+            advanced_type: advanced_type.into(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd)]
+pub enum LEDNode {
+    KbdLed(KeyboardLed),
+    Rog(HidRaw),
+    None,
+}
+
+pub struct CtrlKbdLed {
+    // TODO: config stores the keyboard type as an AuraPower, use or update this
+    pub led_prod: AuraDevice,
+    pub led_node: LEDNode,
+    pub kd_brightness: KeyboardLed,
+    pub supported_modes: LaptopLedData,
+    pub flip_effect_write: bool,
+    pub per_key_mode_active: bool,
+    pub config: AuraConfig,
+}
+
+impl CtrlKbdLed {
+    pub fn new(supported_modes: LaptopLedData) -> Result<Self, RogError> {
+        let mut led_prod = AuraDevice::Unknown;
+        let mut usb_node = None;
+        for prod in ASUS_KEYBOARD_DEVICES {
+            match HidRaw::new(prod.into()) {
+                Ok(node) => {
+                    led_prod = prod;
+                    usb_node = Some(node);
+                    info!(
+                        "Looked for keyboard controller 0x{}: Found",
+                        <&str>::from(prod)
+                    );
+                    break;
+                }
+                Err(err) => info!(
+                    "Looked for keyboard controller 0x{}: {err}",
+                    <&str>::from(prod)
+                ),
+            }
+        }
+
+        let rgb_led = KeyboardLed::new()?;
+
+        if usb_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!(
+                        "kbd_rgb_mode was not found in the /sys/. You require a minimum 6.1 \
+                         kernel and a supported TUF laptop"
+                    );
+                }
+            }
+            return Err(RogError::NoAuraKeyboard);
+        }
+
+        let led_node = if let Some(rog) = usb_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 mut config_init = AuraConfig::create_default(led_prod, &supported_modes);
+        let mut config_loaded = config_init.clone().load();
+
+        for mode in &mut config_init.builtins {
+            // update init values from loaded values if they exist
+            if let Some(loaded) = config_loaded.builtins.get(mode.0) {
+                *mode.1 = loaded.clone();
+            }
+        }
+        config_loaded.builtins = config_init.builtins;
+
+        if let (Some(mut multizone_init), Some(multizone_loaded)) =
+            (config_init.multizone, config_loaded.multizone.as_mut())
+        {
+            for mode in multizone_init.iter_mut() {
+                // update init values from loaded values if they exist
+                if let Some(loaded) = multizone_loaded.get(mode.0) {
+                    let mut new_set = Vec::new();
+                    // only reuse a zone mode if the mode is supported
+                    for mode in loaded {
+                        if supported_modes.basic_modes.contains(&mode.mode) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
+        let ctrl = CtrlKbdLed {
+            led_prod,
+            led_node,               // on TUF this is the same as rgb_led / kd_brightness
+            kd_brightness: rgb_led, // If was none then we already returned above
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config: config_loaded,
+        };
+        Ok(ctrl)
+    }
+
+    pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
+        self.kd_brightness
+            .get_brightness()
+            .map_err(RogError::Platform)
+    }
+
+    pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
+        self.kd_brightness
+            .set_brightness(brightness as u8)
+            .map_err(RogError::Platform)
+    }
+
+    pub fn next_brightness(&mut self) -> Result<(), RogError> {
+        let mut bright = (self.config.brightness as u32) + 1;
+        if bright > 3 {
+            bright = 0;
+        }
+        self.config.brightness = <LedBrightness>::from(bright);
+        self.config.write();
+        self.set_brightness(self.config.brightness)
+    }
+
+    pub fn prev_brightness(&mut self) -> Result<(), RogError> {
+        let mut bright = self.config.brightness as u32;
+        if bright == 0 {
+            bright = 3;
+        } else {
+            bright -= 1;
+        }
+        self.config.brightness = <LedBrightness>::from(bright);
+        self.config.write();
+        self.set_brightness(self.config.brightness)
+    }
+
+    /// Set combination state for boot animation/sleep animation/all leds/keys
+    /// leds/side leds LED active
+    pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &mut self.led_node {
+            if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
+                let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8];
+                platform.set_kbd_rgb_state(&buf)?;
+            }
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
+            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2]];
+
+            hid_raw.write_bytes(&message)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        }
+        Ok(())
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    pub(crate) fn set_effect(&mut self, effect: AuraEffect) -> Result<(), RogError> {
+        if !self.supported_modes.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !self.supported_modes.basic_zones.contains(&effect.zone)
+        {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        self.write_mode(&effect)?;
+        self.config.read(); // refresh config if successful
+        self.config.set_builtin(effect);
+        self.config.write();
+        Ok(())
+    }
+
+    /// Write an effect block. This is for per-key, but can be repurposed to
+    /// write the raw factory mode packets - when doing this it is expected that
+    /// only the first `Vec` (`effect[0]`) is valid.
+    pub fn write_effect_block(&mut self, effect: &UsbPackets) -> 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 = LedUsbPackets::get_init_msg();
+                    hid_raw.write_bytes(&init)?;
+                }
+                self.per_key_mode_active = true;
+            }
+            if let LEDNode::Rog(hid_raw) = &self.led_node {
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
+            } else if let LEDNode::KbdLed(tuf) = &self.led_node {
+                for row in effect.iter() {
+                    let r = row[9];
+                    let g = row[10];
+                    let b = row[11];
+                    tuf.set_kbd_rgb_mode(&[0, 0, r, g, b, 0])?;
+                }
+            }
+            self.flip_effect_write = !self.flip_effect_write;
+        }
+        Ok(())
+    }
+
+    pub(super) fn toggle_mode(&mut self, reverse: bool) -> Result<(), RogError> {
+        let current = self.config.current_mode;
+        if let Some(idx) = self
+            .supported_modes
+            .basic_modes
+            .iter()
+            .position(|v| *v == current)
+        {
+            let mut idx = idx;
+            // goes past end of array
+            if reverse {
+                if idx == 0 {
+                    idx = self.supported_modes.basic_modes.len() - 1;
+                } else {
+                    idx -= 1;
+                }
+            } else {
+                idx += 1;
+                if idx == self.supported_modes.basic_modes.len() {
+                    idx = 0;
+                }
+            }
+            let next = self.supported_modes.basic_modes[idx];
+
+            self.config.read();
+            // if self.config.builtins.contains_key(&next) {
+            self.config.current_mode = next;
+            self.write_current_config_mode()?;
+            // }
+            self.config.write();
+        }
+
+        Ok(())
+    }
+
+    fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &self.led_node {
+            let buf = [
+                1,
+                mode.mode as u8,
+                mode.colour1.0,
+                mode.colour1.1,
+                mode.colour1.2,
+                mode.speed as u8,
+            ];
+            platform.set_kbd_rgb_mode(&buf)?;
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes: [u8; LED_MSG_LEN] = mode.into();
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
+        }
+        self.per_key_mode_active = false;
+        Ok(())
+    }
+
+    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
+        if self.config.multizone_on {
+            let mode = self.config.current_mode;
+            let mut create = false;
+            // There is no multizone config for this mode so create one here
+            // using the colours of rainbow if it exists, or first available
+            // mode, or random
+            if self.config.multizone.is_none() {
+                create = true;
+            } else if let Some(multizones) = self.config.multizone.as_ref() {
+                if !multizones.contains_key(&mode) {
+                    create = true;
+                }
+            }
+            if create {
+                info!("No user-set config for zone founding, attempting a default");
+                self.create_multizone_default()?;
+            }
+
+            if let Some(multizones) = self.config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_mode(&mode)?;
+                    }
+                }
+            }
+        } else {
+            let mode = self.config.current_mode;
+            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
+                self.write_mode(&effect)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
+    fn create_multizone_default(&mut self) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in self.supported_modes.basic_zones.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.config.current_mode,
+                zone: *tmp,
+                colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                speed: Speed::Med,
+                direction: Direction::Left,
+            });
+        }
+        if default.is_empty() {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        if let Some(multizones) = self.config.multizone.as_mut() {
+            multizones.insert(self.config.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.config.current_mode, default);
+            self.config.multizone = Some(tmp);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::aura_detection::LaptopLedData;
+    use rog_aura::usb::AuraDevice;
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+    use rog_platform::keyboard_led::KeyboardLed;
+
+    use super::CtrlKbdLed;
+    use crate::ctrl_aura::config::AuraConfig;
+    use crate::ctrl_aura::controller::LEDNode;
+
+    #[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::create_default(AuraDevice::X19b6, &LaptopLedData::default());
+        let supported_modes = LaptopLedData {
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::AdvancedAuraType::None,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: AuraDevice::X19b6,
+            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.basic_zones.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::create_default(AuraDevice::X19b6, &LaptopLedData::default());
+        let supported_modes = LaptopLedData {
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::AdvancedAuraType::None,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: AuraDevice::X19b6,
+            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.basic_zones.push(AuraZone::Key1);
+        controller.supported_modes.basic_zones.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::create_default(AuraDevice::X19b6, &LaptopLedData::default());
+        let supported_modes = LaptopLedData {
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![AuraZone::Key1, AuraZone::Key2],
+            advanced_type: rog_aura::AdvancedAuraType::None,
+        };
+        let mut controller = CtrlKbdLed {
+            led_prod: AuraDevice::X19b6,
+            led_node: LEDNode::None,
+            kd_brightness: KeyboardLed::default(),
+            supported_modes,
+            flip_effect_write: false,
+            per_key_mode_active: false,
+            config,
+        };
+
+        assert!(controller.config.multizone.is_none());
+        controller.config.multizone_on = true;
+        // This is called in toggle_mode. It will error here because we have no
+        // keyboard node in tests.
+        assert_eq!(
+            controller
+                .write_current_config_mode()
+                .unwrap_err()
+                .to_string(),
+            "No supported Aura keyboard"
+        );
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+}

daemon/src/ctrl_aura/mod.rs

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

daemon/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,327 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{error, info, warn};
+use rog_aura::advanced::UsbPackets;
+use rog_aura::usb::AuraPowerDev;
+use rog_aura::{AuraEffect, AuraModeNum, LedBrightness};
+use zbus::export::futures_util::lock::{Mutex, MutexGuard};
+use zbus::export::futures_util::StreamExt;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use super::controller::CtrlKbdLed;
+use crate::error::RogError;
+use crate::CtrlTask;
+
+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()
+    }
+
+    /// On machine that have some form of either per-key keyboard or per-zone
+    /// this can be used to write custom effects over dbus. The input is a
+    /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
+    async fn direct_addressing_raw(&self, data: UsbPackets) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_effect_block(&data)?;
+        Ok(())
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    async fn led_brightness(&self) -> i8 {
+        let ctrl = self.0.lock().await;
+        ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        signal_ctxt: &SignalContext<'_>,
+        data: &AuraPowerDev,
+    ) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl CtrlTask for CtrlKbdLedZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save = |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| {
+            // If waking up
+            if !start {
+                info!("CtrlKbdLedTask reloading brightness and modes");
+                lock.set_brightness(lock.config.brightness)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+                lock.write_current_config_mode()
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            } else if start {
+                info!("CtrlKbdLedTask saving last brightness");
+                Self::update_config(&mut lock)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            }
+        };
+
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            // Loop so that we do aquire the lock but also don't block other
+            // threads (prevents potential deadlocks)
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    load_save(true, lock);
+                }
+            },
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    load_save(false, lock);
+                }
+            },
+        )
+        .await;
+
+        let ctrl2 = self.0.clone();
+        let ctrl = self.0.lock().await;
+        let mut watch = ctrl.kd_brightness.monitor_brightness()?;
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    if let Some(lock) = ctrl2.try_lock() {
+                        load_save(true, lock);
+                    }
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlKbdLedZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_current_config_mode()?;
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

daemon/src/ctrl_platform.rs

@@ -0,0 +1,382 @@
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::Path;
+use std::process::Command;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{info, warn};
+use rog_platform::platform::{AsusPlatform, GpuMode};
+use rog_platform::supported::RogBiosSupportedFunctions;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{task_watch_item, CtrlTask, GetSupported};
+
+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 data = std::fs::read(ASUS_POST_LOGO_SOUND)
+            .map_err(|err| RogError::Read(ASUS_POST_LOGO_SOUND.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();
+        #[allow(clippy::verbose_file_reads)]
+        file.read_to_end(&mut data)
+            .map_err(|err| RogError::Read(path.into(), err))?;
+
+        let idx = data.len() - 1;
+        if on {
+            data[idx] = 1;
+            info!("Set boot POST sound on");
+        } else {
+            data[idx] = 0;
+            info!("Set boot POST sound off");
+        }
+        file.write_all(&data)
+            .map_err(|err| RogError::Path(path.into(), err))?;
+
+        Ok(())
+    }
+
+    fn set_panel_overdrive(&self, enable: bool) -> Result<(), RogError> {
+        self.platform.set_panel_od(enable).map_err(|err| {
+            warn!("CtrlRogBios: set_panel_overdrive {}", err);
+            err
+        })?;
+        Ok(())
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlPlatform {
+    async fn set_gpu_mux_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        mode: GpuMode,
+    ) {
+        self.set_gfx_mode(mode)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_gpu_mux_mode {}", err);
+                err
+            })
+            .ok();
+        Self::notify_gpu_mux_mode(&ctxt, mode).await.ok();
+    }
+
+    fn gpu_mux_mode(&self) -> GpuMode {
+        match self.platform.get_gpu_mux_mode() {
+            Ok(m) => GpuMode::from_mux(m as u8),
+            Err(e) => {
+                warn!("CtrlRogBios: get_gfx_mode {}", e);
+                GpuMode::Error
+            }
+        }
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_gpu_mux_mode(
+        signal_ctxt: &SignalContext<'_>,
+        mode: GpuMode,
+    ) -> zbus::Result<()> {
+    }
+
+    async fn set_post_boot_sound(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        on: bool,
+    ) {
+        Self::set_boot_sound(on)
+            .map_err(|err| {
+                warn!("CtrlRogBios: set_post_boot_sound {}", err);
+                err
+            })
+            .ok();
+        Self::notify_post_boot_sound(&ctxt, on).await.ok();
+    }
+
+    fn post_boot_sound(&self) -> i8 {
+        Self::get_boot_sound()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_boot_sound {}", err);
+                err
+            })
+            .unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
+
+    async fn set_panel_od(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        overdrive: bool,
+    ) {
+        match self.platform.set_panel_od(overdrive) {
+            Ok(_) => {
+                if let Some(mut lock) = self.config.try_lock() {
+                    lock.panel_od = overdrive;
+                    lock.write();
+                }
+                Self::notify_panel_od(&ctxt, overdrive).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_panel_overdrive {}", err),
+        };
+    }
+
+    /// Get the `panel_od` value from platform. Updates the stored value in
+    /// internal config also.
+    fn panel_od(&self) -> bool {
+        let od = self
+            .platform
+            .get_panel_od()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_panel_od {}", err);
+                err
+            })
+            .unwrap_or(false);
+        if let Some(mut lock) = self.config.try_lock() {
+            lock.panel_od = od;
+            lock.write();
+        }
+        od
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
+    }
+
+    async fn set_dgpu_disable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        disable: bool,
+    ) {
+        match self.platform.set_dgpu_disable(disable) {
+            Ok(_) => {
+                Self::notify_dgpu_disable(&ctxt, disable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_dgpu_disable {}", err),
+        };
+    }
+
+    fn dgpu_disable(&self) -> bool {
+        self.platform
+            .get_dgpu_disable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_dgpu_disable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_dgpu_disable(
+        signal_ctxt: &SignalContext<'_>,
+        disable: bool,
+    ) -> zbus::Result<()> {
+    }
+
+    async fn set_egpu_enable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enable: bool,
+    ) {
+        match self.platform.set_egpu_enable(enable) {
+            Ok(_) => {
+                Self::notify_egpu_enable(&ctxt, enable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_egpu_enable {}", err),
+        };
+    }
+
+    fn egpu_enable(&self) -> bool {
+        self.platform
+            .get_egpu_enable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_egpu_enable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlPlatform {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Platform", server).await;
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlPlatform {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if self.platform.has_panel_od() {
+            let p = if let Some(lock) = self.config.try_lock() {
+                lock.panel_od
+            } else {
+                false
+            };
+            self.set_panel_overdrive(p)?;
+        }
+        Ok(())
+    }
+}
+
+impl CtrlPlatform {
+    task_watch_item!(panel_od platform);
+
+    task_watch_item!(dgpu_disable platform);
+
+    task_watch_item!(egpu_enable platform);
+    // NOTE: see note further below
+    // task_watch_item!(gpu_mux_mode platform);
+}
+
+#[async_trait]
+impl CtrlTask for CtrlPlatform {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let platform1 = self.clone();
+        let platform2 = self.clone();
+        self.create_sys_event_tasks(
+            move || async { {} },
+            move || {
+                let platform1 = platform1.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform1.config.lock().await;
+                    if platform1.platform.has_panel_od() {
+                        platform1
+                            .set_panel_overdrive(lock.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: set_limit {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move || async { {} },
+            move || {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform2.config.lock().await;
+                    if platform2.platform.has_panel_od() {
+                        platform2
+                            .set_panel_overdrive(lock.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: set_limit {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        self.watch_panel_od(signal_ctxt.clone()).await?;
+        self.watch_dgpu_disable(signal_ctxt.clone()).await?;
+        self.watch_egpu_enable(signal_ctxt.clone()).await?;
+        // NOTE: Can't have this as a watch because on a write to it, it reverts back to
+        // booted-with value  as it does not actually change until reboot.
+        // self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+
+        Ok(())
+    }
+}

daemon/src/ctrl_power.rs

@@ -0,0 +1,287 @@
+use std::process::Command;
+use std::sync::Arc;
+use std::time::Duration;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{error, info, warn};
+use rog_platform::power::AsusPower;
+use rog_platform::supported::ChargeSupportedFunctions;
+use systemd_zbus::{ManagerProxy as SystemdProxy, Mode, UnitFileState};
+use tokio::time::sleep;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use crate::config::Config;
+use crate::error::RogError;
+use crate::{task_watch_item, CtrlTask, GetSupported};
+
+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 {
+    task_watch_item!(charge_control_end_threshold power);
+
+    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(())
+    }
+}
+
+#[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 conn = zbus::Connection::system().await?;
+        let sysd1 = SystemdProxy::new(&conn).await?;
+        let sysd2 = sysd1.clone();
+        let sysd3 = sysd1.clone();
+
+        let power1 = self.clone();
+        let power2 = self.clone();
+        self.create_sys_event_tasks(
+            move || async {},
+            move || {
+                let power = power1.clone();
+                let sysd = sysd1.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power.config.lock().await;
+                    power
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+
+                    if lock.disable_nvidia_powerd_on_battery {
+                        if let Ok(value) = power.power.get_online() {
+                            do_nvidia_powerd_action(&sysd, value == 1).await;
+                        }
+                    }
+                }
+            },
+            move || async {},
+            move || {
+                let power = power2.clone();
+                let sysd = sysd2.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power.config.lock().await;
+                    power
+                        .set(lock.bat_charge_limit)
+                        .map_err(|err| {
+                            warn!("CtrlCharge: set_limit {}", err);
+                            err
+                        })
+                        .ok();
+
+                    if lock.disable_nvidia_powerd_on_battery {
+                        if let Ok(value) = power.power.get_online() {
+                            do_nvidia_powerd_action(&sysd, value == 1).await;
+                        }
+                    }
+                }
+            },
+        )
+        .await;
+
+        let config = self.config.clone();
+        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+            .await?;
+
+        let ctrl = self.clone();
+        tokio::spawn(async move {
+            let mut online = 10;
+            loop {
+                if let Ok(value) = ctrl.power.get_online() {
+                    if online != value {
+                        online = value;
+                        let mut config = config.lock().await;
+                        config.read();
+
+                        if config.disable_nvidia_powerd_on_battery {
+                            do_nvidia_powerd_action(&sysd3, value == 1).await;
+                        }
+
+                        Self::notify_mains_online(&signal_ctxt, value == 1)
+                            .await
+                            .unwrap();
+
+                        let mut prog: Vec<&str> = Vec::new();
+                        if value == 1 {
+                            // AC ONLINE
+                            prog = config.ac_command.split_whitespace().collect();
+                        } else if value == 0 {
+                            // BATTERY
+                            prog = config.bat_command.split_whitespace().collect();
+                        }
+
+                        if prog.len() > 1 {
+                            let mut cmd = Command::new(prog[0]);
+                            for arg in prog.iter().skip(1) {
+                                cmd.arg(*arg);
+                            }
+                            if let Err(e) = cmd.spawn() {
+                                if value == 1 {
+                                    error!("AC power command error: {e}");
+                                } else {
+                                    error!("Battery power command error: {e}");
+                                }
+                            }
+                        }
+                    }
+                }
+                // The inotify doesn't pick up events when the kernel changes internal value
+                // so we need to watch it with a thread and sleep unfortunately
+                sleep(Duration::from_secs(1)).await;
+            }
+        });
+
+        Ok(())
+    }
+}
+
+async fn do_nvidia_powerd_action(proxy: &SystemdProxy<'_>, ac_on: bool) {
+    if let Ok(res) = proxy.get_unit_file_state(NVIDIA_POWERD).await {
+        if res == UnitFileState::Enabled {
+            if ac_on {
+                proxy
+                    .start_unit(NVIDIA_POWERD, Mode::Replace)
+                    .await
+                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
+                    .ok();
+            } else {
+                proxy
+                    .stop_unit(NVIDIA_POWERD, Mode::Replace)
+                    .await
+                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
+                    .ok();
+            }
+        }
+    }
+}

daemon/src/ctrl_profiles/config.rs

@@ -0,0 +1,60 @@
+use std::path::PathBuf;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_profiles::fan_curve_set::FanCurveSet;
+use rog_profiles::Profile;
+use serde_derive::{Deserialize, Serialize};
+
+use crate::CONFIG_PATH_BASE;
+
+const CONFIG_FILE: &str = "profile.ron";
+const CONFIG_FAN_FILE: &str = "fan_curves.ron";
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct ProfileConfig {
+    /// For restore on boot
+    pub active_profile: Profile,
+}
+
+impl StdConfig for ProfileConfig {
+    fn new() -> Self {
+        Self {
+            active_profile: Profile::Balanced,
+        }
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for ProfileConfig {}
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub balanced: FanCurveSet,
+    pub performance: FanCurveSet,
+    pub quiet: FanCurveSet,
+}
+
+impl StdConfig for FanCurveConfig {
+    /// Create a new config. The defaults are zeroed so the device must be read
+    /// to get the actual device defaults.
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FAN_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad for FanCurveConfig {}

daemon/src/ctrl_profiles/controller.rs

@@ -0,0 +1,191 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{info, warn};
+use rog_platform::platform::AsusPlatform;
+use rog_platform::supported::PlatformProfileFunctions;
+use rog_profiles::error::ProfileError;
+use rog_profiles::{FanCurveProfiles, Profile};
+
+use super::config::{FanCurveConfig, ProfileConfig};
+use crate::error::RogError;
+use crate::GetSupported;
+
+// TODO: macro wrapper for warn/info/error log macros to add module name
+const MOD_NAME: &str = "CtrlPlatformProfile";
+
+pub struct FanCurves {
+    config_file: FanCurveConfig,
+    profiles: FanCurveProfiles,
+}
+
+impl FanCurves {
+    pub fn update_profiles_from_config(&mut self) {
+        self.profiles.balanced = self.config_file.balanced.clone();
+        self.profiles.performance = self.config_file.performance.clone();
+        self.profiles.quiet = self.config_file.quiet.clone();
+    }
+
+    pub fn update_config_from_profiles(&mut self) {
+        self.config_file.balanced = self.profiles.balanced.clone();
+        self.config_file.performance = self.profiles.performance.clone();
+        self.config_file.quiet = self.profiles.quiet.clone();
+    }
+
+    pub fn profiles(&self) -> &FanCurveProfiles {
+        &self.profiles
+    }
+
+    pub fn profiles_mut(&mut self) -> &mut FanCurveProfiles {
+        &mut self.profiles
+    }
+}
+
+pub struct CtrlPlatformProfile {
+    pub profile_config: ProfileConfig,
+    pub fan_curves: Option<FanCurves>,
+    pub platform: AsusPlatform,
+}
+
+impl GetSupported for CtrlPlatformProfile {
+    type A = PlatformProfileFunctions;
+
+    fn get_supported() -> Self::A {
+        if !Profile::is_platform_profile_supported() {
+            warn!(
+                "platform_profile kernel interface not found, your laptop does not support this, \
+                 or the interface is missing."
+            );
+        }
+
+        let res = FanCurveProfiles::is_supported();
+        let mut fan_curve_supported = res.is_err();
+        if let Ok(r) = res {
+            fan_curve_supported = r;
+        };
+
+        if !fan_curve_supported {
+            info!(
+                "fan curves kernel interface not found, your laptop does not support this, or the \
+                 interface is missing."
+            );
+        }
+
+        PlatformProfileFunctions {
+            platform_profile: Profile::is_platform_profile_supported(),
+            fan_curves: fan_curve_supported,
+        }
+    }
+}
+
+impl CtrlPlatformProfile {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
+        let platform = AsusPlatform::new()?;
+        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
+            info!("{MOD_NAME}: Device has profile control available");
+
+            let mut controller = CtrlPlatformProfile {
+                profile_config: config,
+                fan_curves: None,
+                platform,
+            };
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("{MOD_NAME}: Device has fan curves available");
+                let fan_config = FanCurveConfig::new();
+                // Only do defaults if the config doesn't already exist
+                if !fan_config.file_path().exists() {
+                    info!("{MOD_NAME}: Fetching default fan curves");
+                    controller.fan_curves = Some(FanCurves {
+                        config_file: fan_config,
+                        profiles: FanCurveProfiles::default(),
+                    });
+                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
+                        // For each profile we need to switch to it before we
+                        // can read the existing values from hardware. The ACPI method used
+                        // for this is what limits us.
+                        controller.set_next_profile()?;
+                        // Make sure to set the baseline to default
+                        controller.set_active_curve_to_defaults()?;
+                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+                        if let Some(curves) = controller.fan_curves.as_ref() {
+                            info!(
+                                "{MOD_NAME}: {active:?}: {}",
+                                String::from(curves.profiles().get_fan_curves_for(active))
+                            );
+                        }
+                    }
+                    if let Some(curves) = controller.fan_curves.as_ref() {
+                        curves.config_file.write();
+                    }
+                } else {
+                    info!("{MOD_NAME}: Fan curves previously stored, loading...");
+                    let mut fan_curves = FanCurves {
+                        config_file: fan_config.load(),
+                        profiles: FanCurveProfiles::default(),
+                    };
+                    fan_curves.update_profiles_from_config();
+                    controller.fan_curves = Some(fan_curves);
+                }
+            }
+
+            return Ok(controller);
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+
+    pub fn save_config(&mut self) {
+        self.profile_config.write();
+        if let Some(fans) = self.fan_curves.as_mut() {
+            fans.update_config_from_profiles();
+            fans.config_file.write(); // config write
+        }
+    }
+
+    /// Toggle to next profile in list. This will first read the config, switch,
+    /// then write out
+    pub(super) fn set_next_profile(&mut self) -> Result<(), RogError> {
+        // Read first just incase the user has modified the config before calling this
+        match self.profile_config.active_profile {
+            Profile::Balanced => {
+                Profile::set_profile(Profile::Performance)?;
+                self.profile_config.active_profile = Profile::Performance;
+            }
+            Profile::Performance => {
+                Profile::set_profile(Profile::Quiet)?;
+                self.profile_config.active_profile = Profile::Quiet;
+            }
+            Profile::Quiet => {
+                Profile::set_profile(Profile::Balanced)?;
+                self.profile_config.active_profile = Profile::Balanced;
+            }
+        }
+        self.write_profile_curve_to_platform()?;
+        Ok(())
+    }
+
+    /// Set the curve for the active profile active
+    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = &mut self.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().write_profile_curve_to_platform(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
+        if let Some(curves) = self.fan_curves.as_mut() {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                curves.profiles_mut().set_active_curve_to_defaults(
+                    self.profile_config.active_profile,
+                    &mut device,
+                )?;
+                curves.update_config_from_profiles();
+            }
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_profiles/mod.rs

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