adjustor 3.3.1__tar.gz → 3.4.0__tar.gz

{adjustor-3.3.1/src/adjustor.egg-info → adjustor-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.3.1
+Version: 3.4.0
 Summary: Adjustor, a userspace program for managing the TDP of handheld devices.
 Author-email: Kapenekakis Antheas <pypi@antheas.dev>
 Project-URL: Homepage, https://github.com/hhd-dev/adjustor
@@ -38,7 +38,7 @@ except intel handhelds and older prior to 6XXX AMD handhelds.
 ## TDP Control
 For the ROG Ally, Ally X and Legion Go that have an ACPI/EC implementation for 
 bios and fan curves,
-Adjustor uses the manufactuer functions for setting TDP.
+Adjustor uses the manufacturer functions for setting TDP.
 For the Allys, the asus-wmi kernel driver is used to set the tdp and manage the
 fan curves.
 For the Go, Lenovo's WMI methods are called through `acpi_call`, which will hopefully
@@ -53,14 +53,14 @@ For more, see [AMD TDP Control Details](#amd-tdp).
 In all cases, there are checks to ensure that the TDP is within the safe range
 of the processors.
 
-## Energy Management
-Adjustor can also manage the energy profile of the processor, by setting EPP
+## Energy Management in Handhelds
+Adjustor can also manage the energy profile of the processor in handhelds, by setting EPP
 and proper frequency values.
 After we transitioned people away from Decky plugins (which had some governor controls)
 to using Handheld Daemon for TDP, we found that Power Profiles Daemon (PPD) 
 would use aggressive CPU values.
 These values are optimized for devices that have a dedicated power budget for the CPU
-(e.g., laptops, desktops), which caused issues with handhelds.
+(e.g., laptops, desktops), which causes undesirable behavior handhelds.
 
 For example, the balanced PPD profile would set EPP to balance_performance and
 enable CPU boost, which would increase the draw of the CPU during gaming by 2W
@@ -91,6 +91,48 @@ TDP range instead of CPU values (which is the user's expectation).
 Of course, depending on TDP and user preference, the CPU governor values will be set
 accordingly.
 
+## Energy Management in other computers
+As we design Handheld Daemon to be enabled in more Deck style devices (e.g., HTPCs), 
+these devices have different power requirements and processors (e.g., Intel), which 
+are better managed with Power Profiles Daemon.
+It is the aim of the Handheld Daemon project to become a general Deck style session 
+manager for anything gamescope related, with useful features for all devices.
+
+In these cases, starting with 3.4, for devices that are not in the CPU/device
+whitelist (includes only AMD U series APUs and handhelds), Adjustor contains a 
+general energy management plugin that allows for switching the PPD power profile 
+from game mode.
+In addition, it supports [sched_ext schedulers](#sched_ext).
+
+This means that for general devices, Handheld Daemon uses PPD, and for handhelds,
+Handheld Daemon becomes PPD.
+This can be confusing for distribution maintainers and users, as they can and 
+should install both (e.g., Adjustor uses the Power Profile Daemon polkits).
+
+In any case, Adjustor will never break/conflict with PPD and contains helpful 
+messages about disabling PPD in case the optimized handheld plugin is loaded.
+For distribution maintainers that ship both and want Handheld Daemon to work
+without user intervention, the environment variable `HHD_PPD_MASK` is provided.
+If and only if it is set e.g., by using a systemd service extension, Handheld Daemon
+will mask and disable PPD if optimized energy management is supported and enabled (e.g., for handhelds).
+If the general plugin is loaded, it will unmask PPD during startup.
+This means that Power Management will work properly for all devices without manual
+intervention or whitelisting by distribution maintainers.
+
+## Sched_ext<a name="sched-ext"></a>
+Starting with version 3.3, Adjustor can attach sched_ext schedulers to the
+kernel if those are supported and installed.
+Adjustor manages the lifetime of the scheduler, including launching and attaching
+it, without using a systemd service, and is fully responsive to quirk scheduler
+switches.
+
+Schedulers are whitelisted in a case by case basis, with LAVD, rusty, and bpfland
+being supported in the current version (the `scx_` namespace is crowded with e.g.,
+test schedulers).
+Of course, only installed schedulers are shown if and only if the kernel supports
+them.
+Get in touch to add your favorite scheduler, as it is a single line change.
+
 ## AMD TDP Control Details<a name="amd-tdp"></a>
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface
 of AMD, which exposes a superset of the parameters that can be currently found in 
@@ -99,7 +141,7 @@ This vendor interface is part of the ACPI ASL library, and provided through the
 ALIB method 0x0C.
 The underlying implementation of the interface is SMU calls.
 This means that as long as the kernel module `acpi_call` is loaded, Adjustor
-can control TDP in an equivalent way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
+can control TDP in a similar way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
 
 The ABI of this vendor function (as it is provided to manufacturers) can be 
 considered mostly stable, so little work is needed between subsequent 
@@ -109,8 +151,9 @@ Of course, support for processors is only added after the ACPI bindings have
 been reviewed, to avoid surprises.
 Both the Ally and Legion Go use this function, in the exact same way, so setting
 TDP with it is very stable, and we have had no reported crashes.
-It should not be used (and is not used) with those devices, however, as the 
-manufacturer functions will interfere.
+It can not be used and is not used with those devices, however, as the 
+manufacturer functions would interfere and provide a better user experience,
+such as setting appropriate fan curves and changing the power light color on the Legion Go.
 
 Unfortunately for devices that do have an ACPI/EC implementation for TDP, there
 is no official way of setting TDP on demand, either on Linux or Windows, with

{adjustor-3.3.1 → adjustor-3.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adjustor"
-version = "3.3.1"
+version = "3.4.0"
 authors = [
   { name="Kapenekakis Antheas", email="pypi@antheas.dev" },
 ]

{adjustor-3.3.1 → adjustor-3.4.0}/readme.md

@@ -17,7 +17,7 @@ except intel handhelds and older prior to 6XXX AMD handhelds.
 ## TDP Control
 For the ROG Ally, Ally X and Legion Go that have an ACPI/EC implementation for 
 bios and fan curves,
-Adjustor uses the manufactuer functions for setting TDP.
+Adjustor uses the manufacturer functions for setting TDP.
 For the Allys, the asus-wmi kernel driver is used to set the tdp and manage the
 fan curves.
 For the Go, Lenovo's WMI methods are called through `acpi_call`, which will hopefully
@@ -32,14 +32,14 @@ For more, see [AMD TDP Control Details](#amd-tdp).
 In all cases, there are checks to ensure that the TDP is within the safe range
 of the processors.
 
-## Energy Management
-Adjustor can also manage the energy profile of the processor, by setting EPP
+## Energy Management in Handhelds
+Adjustor can also manage the energy profile of the processor in handhelds, by setting EPP
 and proper frequency values.
 After we transitioned people away from Decky plugins (which had some governor controls)
 to using Handheld Daemon for TDP, we found that Power Profiles Daemon (PPD) 
 would use aggressive CPU values.
 These values are optimized for devices that have a dedicated power budget for the CPU
-(e.g., laptops, desktops), which caused issues with handhelds.
+(e.g., laptops, desktops), which causes undesirable behavior handhelds.
 
 For example, the balanced PPD profile would set EPP to balance_performance and
 enable CPU boost, which would increase the draw of the CPU during gaming by 2W
@@ -70,6 +70,48 @@ TDP range instead of CPU values (which is the user's expectation).
 Of course, depending on TDP and user preference, the CPU governor values will be set
 accordingly.
 
+## Energy Management in other computers
+As we design Handheld Daemon to be enabled in more Deck style devices (e.g., HTPCs), 
+these devices have different power requirements and processors (e.g., Intel), which 
+are better managed with Power Profiles Daemon.
+It is the aim of the Handheld Daemon project to become a general Deck style session 
+manager for anything gamescope related, with useful features for all devices.
+
+In these cases, starting with 3.4, for devices that are not in the CPU/device
+whitelist (includes only AMD U series APUs and handhelds), Adjustor contains a 
+general energy management plugin that allows for switching the PPD power profile 
+from game mode.
+In addition, it supports [sched_ext schedulers](#sched_ext).
+
+This means that for general devices, Handheld Daemon uses PPD, and for handhelds,
+Handheld Daemon becomes PPD.
+This can be confusing for distribution maintainers and users, as they can and 
+should install both (e.g., Adjustor uses the Power Profile Daemon polkits).
+
+In any case, Adjustor will never break/conflict with PPD and contains helpful 
+messages about disabling PPD in case the optimized handheld plugin is loaded.
+For distribution maintainers that ship both and want Handheld Daemon to work
+without user intervention, the environment variable `HHD_PPD_MASK` is provided.
+If and only if it is set e.g., by using a systemd service extension, Handheld Daemon
+will mask and disable PPD if optimized energy management is supported and enabled (e.g., for handhelds).
+If the general plugin is loaded, it will unmask PPD during startup.
+This means that Power Management will work properly for all devices without manual
+intervention or whitelisting by distribution maintainers.
+
+## Sched_ext<a name="sched-ext"></a>
+Starting with version 3.3, Adjustor can attach sched_ext schedulers to the
+kernel if those are supported and installed.
+Adjustor manages the lifetime of the scheduler, including launching and attaching
+it, without using a systemd service, and is fully responsive to quirk scheduler
+switches.
+
+Schedulers are whitelisted in a case by case basis, with LAVD, rusty, and bpfland
+being supported in the current version (the `scx_` namespace is crowded with e.g.,
+test schedulers).
+Of course, only installed schedulers are shown if and only if the kernel supports
+them.
+Get in touch to add your favorite scheduler, as it is a single line change.
+
 ## AMD TDP Control Details<a name="amd-tdp"></a>
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface
 of AMD, which exposes a superset of the parameters that can be currently found in 
@@ -78,7 +120,7 @@ This vendor interface is part of the ACPI ASL library, and provided through the
 ALIB method 0x0C.
 The underlying implementation of the interface is SMU calls.
 This means that as long as the kernel module `acpi_call` is loaded, Adjustor
-can control TDP in an equivalent way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
+can control TDP in a similar way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
 
 The ABI of this vendor function (as it is provided to manufacturers) can be 
 considered mostly stable, so little work is needed between subsequent 
@@ -88,8 +130,9 @@ Of course, support for processors is only added after the ACPI bindings have
 been reviewed, to avoid surprises.
 Both the Ally and Legion Go use this function, in the exact same way, so setting
 TDP with it is very stable, and we have had no reported crashes.
-It should not be used (and is not used) with those devices, however, as the 
-manufacturer functions will interfere.
+It can not be used and is not used with those devices, however, as the 
+manufacturer functions would interfere and provide a better user experience,
+such as setting appropriate fan curves and changing the power light color on the Legion Go.
 
 Unfortunately for devices that do have an ACPI/EC implementation for TDP, there
 is no official way of setting TDP on demand, either on Linux or Windows, with

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/amd/__init__.py

@@ -24,7 +24,7 @@ from adjustor.fuse.gpu import (
 
 logger = logging.getLogger(__name__)
 
-APPLY_DELAY = 0.5
+APPLY_DELAY = 0.2
 
 
 def _ppd_client(emit, proc):
@@ -126,14 +126,29 @@ class AmdGPUPlugin(HHDPlugin):
                 ]
             )
             for line in out.decode().splitlines():
-                if "not-found" in line.lower():
+                line = line.lower()
+                if "masked" in line:
                     continue
-                if "power-profiles-daemon" in line or "tuned" in line.lower():
+                if "not-found" in line:
+                    continue
+                if "inactive" in line:
+                    continue
+                if "power-profiles-daemon" in line or "tuned" in line:
                     self.ppd_conflict = True
                     break
         except Exception as e:
             logger.error(f"Failed to check for PPD conflict:\n{e}")
 
+        if self.ppd_conflict and os.environ.get("HHD_PPD_MASK", None):
+            logger.warning(
+                "PPD conflict detected but HHD_PPD_MASK is set. Masking PPD."
+            )
+            # Mask and disable
+            os.system("systemctl mask power-profiles-daemon.service")
+            os.system("systemctl disable --now power-profiles-daemon.service")
+            # Keep going without check to avoid obscure errors
+            self.ppd_conflict = False
+
         if self.ppd_conflict:
             self.initialized = False
             return {

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/amd/settings.yml

@@ -46,6 +46,11 @@ enabled:
               options:
                 min: 400MHz
                 nonlinear: 1GHz
+              hint: >-
+                Sets the minimum frequency for the CPU.
+                Using 400MHz will save battery in light games.
+                However, the delay of increasing the frequency
+                may cause minor stutters, especially in VRR displays.
             cpu_boost:
               type: multiple
               title: CPU Boost

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/asus/__init__.py

@@ -9,8 +9,8 @@ from adjustor.core.platform import set_platform_profile
 
 logger = logging.getLogger(__name__)
 
-APPLY_DELAY = 1.5
-TDP_DELAY = 0.2
+APPLY_DELAY = 0.7
+TDP_DELAY = 0.1
 MIN_TDP_START = 7
 MAX_TDP_START = 30
 # FIXME: add AC/DC values
@@ -123,7 +123,7 @@ def disable_fan_curve():
 
 
 class AsusDriverPlugin(HHDPlugin):
-    def __init__(self) -> None:
+    def __init__(self, allyx: bool = False) -> None:
         self.name = f"adjustor_asus"
         self.priority = 6
         self.log = "adja"
@@ -132,11 +132,16 @@ class AsusDriverPlugin(HHDPlugin):
         self.enforce_limits = True
         self.startup = True
         self.old_conf = None
+        self.mode = None
+        self.cycle_tdp = None
 
         self.queue_fan = None
         self.queue_tdp = None
         self.new_tdp = None
+        self.new_mode = None
         self.old_target = None
+        self.pp = None
+        self.allyx = allyx
 
     def settings(self):
         if not self.enabled:
@@ -147,8 +152,25 @@ class AsusDriverPlugin(HHDPlugin):
 
         self.initialized = True
         out = {"tdp": {"asus": load_relative_yaml("settings.yml")}}
+
+        # Set units
+        if self.allyx:
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["quiet"]["unit"] = "13W"
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["balanced"]["unit"] = "17W"
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["performance"][
+                "unit"
+            ] = "25W"
+        else:
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["quiet"]["unit"] = "10W"
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["balanced"]["unit"] = "15W"
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["performance"][
+                "unit"
+            ] = "20W"
+
         if not self.enforce_limits:
-            out["tdp"]["asus"]["children"]["tdp"]["max"] = 50
+            out["tdp"]["asus"]["children"]["tdp_v2"]["modes"]["custom"]["children"]["tdp"][
+                "max"
+            ] = 50
         return out
 
     def open(
@@ -204,78 +226,120 @@ class AsusDriverPlugin(HHDPlugin):
         # TDP
         #
         new_target = None
-
-        # Reset fan curve on mode change
-        # Has to happen before setting the stdp, ftdp values, in case
-        # we are in custom mode
-        fan_mode = conf["tdp.asus.fan.mode"].to(str)
-        if fan_mode != self.old_conf["fan.mode"].to(str) and fan_mode != "manual":
-            pass
-
-        # Check user changed values
-        if self.new_tdp:
-            steady = self.new_tdp
-            self.new_tdp = None
-            conf["tdp.asus.tdp"] = steady
+        new_tdp = self.new_tdp
+        self.new_tdp = None
+        new_mode = self.new_mode
+        self.new_mode = None
+        ally_x = self.allyx
+        if new_tdp:
+            # For TDP values received from steam, set the appropriate
+            # mode to get a better experience.
+            if new_tdp == (13 if ally_x else 10):
+                mode = "quiet"
+            elif new_tdp == (17 if ally_x else 15):
+                mode = "balanced"
+            elif new_tdp == 25 or new_tdp == 30:
+                mode = "performance"
+            else:
+                mode = "custom"
+            conf["tdp.asus.tdp_v2.mode"] = mode
+        elif new_mode:
+            mode = new_mode
+            conf["tdp.asus.tdp_v2.mode"] = mode
         else:
-            steady = conf["tdp.asus.tdp"].to(int)
-
-        steady_updated = steady and steady != self.old_conf["tdp"].to(int)
+            mode = conf["tdp.asus.tdp_v2.mode"].to(str)
+        self.mode = mode
+
+        tdp_reset = False
+        if mode is not None and mode != self.old_conf["tdp_v2.mode"].to(str):
+            tdp_reset = True
+
+        # Handle EPP for presets
+        if tdp_reset and mode != "custom":
+            match mode:
+                case "quiet":
+                    set_platform_profile("quiet")
+                    new_target = "power"
+                case "balanced":
+                    set_platform_profile("balanced")
+                    new_target = "balanced"
+                case _:  # "performance":
+                    set_platform_profile("performance")
+                    new_target = "performance"
+
+        # In custom mode, re-apply settings with debounce
+        if mode == "custom":
+            # Check user changed values
+            if new_tdp:
+                steady = new_tdp
+                conf["tdp.asus.tdp_v2.custom.tdp"] = steady
+            else:
+                steady = conf["tdp.asus.tdp_v2.custom.tdp"].to(int)
 
-        if self.startup and (steady > MAX_TDP_START or steady < MIN_TDP_START):
-            logger.warning(
-                f"TDP ({steady}) outside the device spec. Resetting for stability reasons."
+            steady_updated = steady and steady != self.old_conf["tdp_v2.custom.tdp"].to(
+                int
             )
-            steady = min(max(steady, MIN_TDP_START), MAX_TDP_START)
-            conf["tdp.asus.tdp"] = steady
-            steady_updated = True
-
-        boost = conf["tdp.asus.boost"].to(bool)
-        boost_updated = boost != self.old_conf["boost"].to(bool)
-
-        # If yes, queue an update
-        # Debounce
-        if self.startup or steady_updated or boost_updated:
-            self.queue_tdp = curr + APPLY_DELAY
-
-        tdp_set = self.queue_tdp and self.queue_tdp < curr
-        if tdp_set:
-            if steady < 5:
-                steady = 5
-            if steady < 13:
-                set_platform_profile("quiet")
-                new_target = "power"
-            elif steady < 20:
-                set_platform_profile("balanced")
-                new_target = "balanced"
-            else:
-                set_platform_profile("performance")
-                new_target = "performance"
-
-            self.queue_tdp = None
-            if boost:
-                # TODO: Use different boost values depending on whether plugged in
-                time.sleep(TDP_DELAY)
-                set_tdp(
-                    "fast", FTDP_FN, min(max(steady, MAX_TDP), int(steady * 35 / 25))
-                )
-                time.sleep(TDP_DELAY)
-                set_tdp(
-                    "slow", STDP_FN, min(max(steady, MAX_TDP), int(steady * 30 / 25))
+            steady_updated |= tdp_reset
+
+            if self.startup and (steady > MAX_TDP_START or steady < MIN_TDP_START):
+                logger.warning(
+                    f"TDP ({steady}) outside the device spec. Resetting for stability reasons."
                 )
-                time.sleep(TDP_DELAY)
-                set_tdp("steady", CTDP_FN, steady)
-            else:
-                time.sleep(TDP_DELAY)
-                set_tdp("fast", FTDP_FN, steady)
-                time.sleep(TDP_DELAY)
-                set_tdp("slow", STDP_FN, steady)
-                time.sleep(TDP_DELAY)
-                set_tdp("steady", CTDP_FN, steady)
+                steady = min(max(steady, MIN_TDP_START), MAX_TDP_START)
+                conf["tdp.asus.tdp_v2.custom.tdp"] = steady
+                steady_updated = True
+
+            boost = conf["tdp.asus.tdp_v2.custom.boost"].to(bool)
+            boost_updated = boost != self.old_conf["tdp_v2.custom.boost"].to(bool)
+
+            # If yes, queue an update
+            # Debounce
+            if self.startup or steady_updated or boost_updated:
+                self.queue_tdp = curr + APPLY_DELAY
+
+            tdp_set = self.queue_tdp and self.queue_tdp < curr
+            if tdp_set:
+                if steady < 5:
+                    steady = 5
+                if steady < (15 if self.allyx else 13):
+                    set_platform_profile("quiet")
+                    new_target = "power"
+                elif steady < (22 if self.allyx else 20):
+                    set_platform_profile("balanced")
+                    new_target = "balanced"
+                else:
+                    set_platform_profile("performance")
+                    new_target = "performance"
+
+                self.queue_tdp = None
+                if boost:
+                    # TODO: Use different boost values depending on whether plugged in
+                    time.sleep(TDP_DELAY)
+                    set_tdp(
+                        "fast",
+                        FTDP_FN,
+                        min(max(steady, MAX_TDP), int(steady * 35 / 25)),
+                    )
+                    time.sleep(TDP_DELAY)
+                    set_tdp(
+                        "slow",
+                        STDP_FN,
+                        min(max(steady, MAX_TDP), int(steady * 30 / 25)),
+                    )
+                    time.sleep(TDP_DELAY)
+                    set_tdp("steady", CTDP_FN, steady)
+                else:
+                    time.sleep(TDP_DELAY)
+                    set_tdp("fast", FTDP_FN, steady)
+                    time.sleep(TDP_DELAY)
+                    set_tdp("slow", STDP_FN, steady)
+                    time.sleep(TDP_DELAY)
+                    set_tdp("steady", CTDP_FN, steady)
 
         if new_target and new_target != self.old_target:
             self.old_target = new_target
             self.emit({"type": "energy", "status": new_target})
+            self.pp = new_target
 
         # Handle fan curve resets
         if conf["tdp.asus.fan.manual.reset"].to(bool):
@@ -283,16 +347,31 @@ class AsusDriverPlugin(HHDPlugin):
             for k, v in zip(POINTS, DEFAULT_CURVE):
                 conf[f"tdp.asus.fan.manual.st{k}"] = v
 
-        # # Handle fan curve limits
-        # if conf["tdp.asus.fan.manual.enforce_limits"].to(bool):
-        #     for k, v in zip(POINTS, MIN_CURVE):
-        #         if conf[f"tdp.asus.fan.manual.st{k}"].to(int) < v:
-        #             conf[f"tdp.asus.fan.manual.st{k}"] = v
+        manual_fan_curve = conf["tdp.asus.fan.mode"].to(str) == "manual"
+
+        # Handle fan curve limits by Asus
+        # by enforcing minimum values based on power profile
+        # which is a proxy of the current platform profile but still
+        # a bit of a hack. TODO: Get the exact limits.
+        # FIXME: Revisit limits
+        # if manual_fan_curve:
+        #     match self.pp:
+        #         case "balanced":
+        #             min_val = 45
+        #         case "performance":
+        #             min_val = 60
+        #         case _:  # quiet
+        #             min_val = 17
+
+        #     for k in POINTS:
+        #         if conf[f"tdp.asus.fan.manual.st{k}"].to(int) < min_val:
+        #             conf[f"tdp.asus.fan.manual.st{k}"] = min_val
 
         # Check if fan curve has changed
         # Use debounce logic on these changes
-        if tdp_set and conf["tdp.asus.fan.mode"].to(str) == "manual":
+        if tdp_reset and manual_fan_curve:
             self.queue_fan = curr + APPLY_DELAY
+
         for i in POINTS:
             if conf[f"tdp.asus.fan.manual.st{i}"].to(int) != self.old_conf[
                 f"fan.manual.st{i}"
@@ -329,6 +408,7 @@ class AsusDriverPlugin(HHDPlugin):
             self.queue_fan = None
 
         # Save current config
+        self.cycle_tdp = conf["tdp.asus.cycle_tdp"].to(bool)
         self.old_conf = conf["tdp.asus"]
 
         if self.startup:
@@ -338,15 +418,35 @@ class AsusDriverPlugin(HHDPlugin):
         for ev in events:
             if ev["type"] == "tdp":
                 self.new_tdp = ev["tdp"]
-            if ev["type"] == "ppd":
-                # TODO: Replace with power modes after refactor
+            elif ev["type"] == "ppd":
                 match ev["status"]:
                     case "power":
-                        self.new_tdp = 8
+                        self.new_mode = "quiet"
+                    case "balanced":
+                        self.new_mode = "balanced"
+                    case "performance":
+                        self.new_mode = "performance"
+            elif self.cycle_tdp and ev['type'] == "special" and ev['event'] == "xbox_y":
+                match self.mode:
+                    case "quiet":
+                        self.new_mode = "balanced"
+                        event = "tdp_cycle_balanced"
                     case "balanced":
-                        self.new_tdp = 15
+                        self.new_mode = "performance"
+                        event = "tdp_cycle_performance"
                     case "performance":
-                        self.new_tdp = 25
+                        self.new_mode = "custom"
+                        event = "tdp_cycle_custom"
+                    case "custom":
+                        self.new_mode = "quiet"
+                        event = "tdp_cycle_quiet"
+                    case _:
+                        self.new_mode = "balanced"
+                        event = "tdp_cycle_balanced"
+
+                logger.info(f"Cycling TDP to '{self.new_mode}'")
+                if self.emit:
+                    self.emit({"type": "special", "event": event})
 
     def close(self):
         pass

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/asus/settings.yml

@@ -4,27 +4,54 @@ tags: [hide-title]
 hint: >-
   Uses the interface of Armory Crate to set the TDP of the device.
 children:
-  tdp:
-    type: int
-    title: TDP
-    hint: >-
-      Average TDP Target.
-
-      Sets the values STAMP and Skin Power Limit to it without boost.
-      With boost, it sets the fast value to 53/30*tdp and the slow value to 43/30*tdp.
-      Boost is recommended for desktop use.
+  tdp_v2:
+    type: mode
+    title: TDP Mode
+    default: balanced
+    modes:
+      quiet:
+        type: container
+        title: Silent
+        unit: 
+      balanced:
+        type: container
+        title: Performance
+        unit: 
+      performance:
+        type: container
+        title: Turbo
+        unit: 
+      custom:
+        type: container
+        title: Custom
+        unit: → 25/30W
+        children:
+          tdp:
+            type: int
+            title: TDP
+            hint: >-
+              Average TDP Target.
+              TDP Boost is recommended for desktop use and does not affect gaming.
 
-    min: 5
-    max: 30
-    step: 1
-    default: 15
-    unit: W
-  boost:
+            min: 0
+            max: 30
+            step: 1
+            default: 30
+            unit: W
+          boost:
+            type: bool
+            title: TDP Boost
+            default: True
+            hint: >-
+              Allows the device to temporarily boost by setting appropriate slow and fast TDPs.
+  
+  cycle_tdp:
     type: bool
-    title: TDP Boost
-    default: True
+    title: Change TDP with View+Y
     hint: >-
-      Allows the device to boost by setting appropriate slow and fast TDPs.
+      Allows you to cycle through TDP modes with the View+Y key combination.
+      Recommended to use with ROG Swap, as the View button will be muted to games.
+    default: False
 
   fan:
     type: mode
@@ -94,8 +121,7 @@ children:
             title: Fan Curve Limitation
             type: display
             default: >-
-              Asus hardware limits the minimum fan curve depending on TDP.
-              The minimums are 25%, 50%, and 75% for low, medium, and high TDPs.
+              Asus hardware limits the minimum fan curve depending on TDP mode.
 
   charge_limit:
     type: multiple
@@ -110,16 +136,4 @@ children:
       p90: 90%
       p95: 95%
       disabled: Unset
-    default: disabled
-  
-  # disclaimer:
-  #   title: Sleep Bug
-  #   type: display
-  #   tags: [ non-essential ]
-  #   default: >-
-  #     There is an Asus kernel/BIOS bug that will sometimes limit TDP to 10W
-  #     after sleep.
-  #     As the kernel driver is used, this is unfixable from within
-  #     Handheld Daemon (currently investigated).
-  #     As an alternative, use SimpleDeckyTDP with RyzenAdj after
-  #     disabling TDP controls from "Settings".
+    default: disabled

adjustor-3.4.0/src/adjustor/drivers/general/__init__.py

@@ -0,0 +1,146 @@
+import os
+import subprocess
+from typing import Literal
+import shutil
+
+import time
+import signal
+from hhd.plugins import Context, HHDPlugin, load_relative_yaml
+from hhd.plugins.conf import Config
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class GeneralPowerPlugin(HHDPlugin):
+
+    def __init__(
+        self,
+    ) -> None:
+        self.name = f"adjustor_general"
+        self.priority = 8
+        self.log = "gpow"
+        self.last_check = None
+        self.target = None
+        self.old_sched = None
+        self.sched_proc = None
+        self.ppd_supported = None
+
+    def settings(self):
+        sets = load_relative_yaml("./settings.yml")
+
+        # PPD
+        if self.ppd_supported is None:
+            self.ppd_supported = False
+            if ppc := shutil.which('powerprofilesctl'):
+                try:
+                    if os.environ.get("HHD_PPD_MASK", None):
+                        logger.info("Unmasking Power Profiles Daemon in the case it was masked.")
+                        os.system('systemctl unmask power-profiles-daemon')
+                    subprocess.run(
+                        [ppc],
+                        check=True,
+                        stdin=subprocess.DEVNULL,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    self.ppd_supported = True
+                except Exception as e:
+                    logger.warning(f"powerprofilectl returned with error:\n{e}")
+
+        if not self.ppd_supported:
+            del sets["children"]["profile"]
+
+        # SchedExt
+        self.avail_scheds = {}
+        avail_pretty = {}
+        kernel_supports = os.path.isfile("/sys/kernel/sched_ext/state")
+        if kernel_supports:
+            for sched, pretty in sets["children"]["sched"]["options"].items():
+                if sched == "disabled":
+                    avail_pretty[sched] = pretty
+                    continue
+
+                exe = shutil.which(sched)
+                if exe:
+                    self.avail_scheds[sched] = exe
+                    avail_pretty[sched] = pretty
+
+        if self.avail_scheds:
+            sets["children"]["sched"]["options"] = avail_pretty
+        else:
+            del sets["children"]["sched"]
+
+        self.logged_boost = True
+        return {
+            "tdp": {"general": sets},
+        }
+
+    def update(self, conf: Config):
+        # Handle ppd
+        if self.ppd_supported:
+            curr = time.time()
+            new_profile = conf.get("tdp.general.profile", self.target)
+            if new_profile != self.target and new_profile and self.target:
+                logger.info(f"Setting power profile to '{new_profile}'")
+                self.target = new_profile
+                try:
+                    subprocess.run(
+                        [shutil.which('powerprofilesctl'), "set", new_profile],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                    )
+                except Exception as e:
+                    self.ppd_supported = False
+                    logger.warning(f"powerprofilesctl returned with error:\n{e}")
+                    self.ppd_supported = False
+            elif not self.last_check or curr - self.last_check > 2:
+                # Update profile every 2 seconds
+                self.last_check = curr
+                try:
+                    res = subprocess.run(
+                        [shutil.which('powerprofilesctl'), "get"],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                    )
+                    self.target = res.stdout.decode().strip()  # type: ignore
+                    if self.target != conf["tdp.general.profile"].to(str):
+                        conf["tdp.general.profile"] = self.target
+                except Exception as e:
+                    self.ppd_supported = False
+                    logger.warning(f"powerprofilectl returned with error:\n{e}")
+                    self.ppd_supported = False
+
+        # Handle sched
+        if self.avail_scheds:
+            # Check health and print error
+            if self.sched_proc and self.sched_proc.poll():
+                err = self.sched_proc.poll()
+                self.sched_proc = None
+                logger.error(
+                    f"Scheduler from sched_ext '{self.old_sched}' closed with error code: {err}"
+                )
+
+            new_sched = conf.get("tdp.general.sched", "disabled")
+            if new_sched != self.old_sched:
+                self.close_sched()
+                self.old_sched = new_sched
+                if new_sched and new_sched != "disabled":
+                    logger.info(f"Starting sched_ext scheduler '{new_sched}'")
+                    self.sched_proc = subprocess.Popen(
+                        self.avail_scheds[new_sched],
+                        stderr=subprocess.DEVNULL,
+                        stdout=subprocess.DEVNULL,
+                    )
+
+    def close_sched(self):
+        if self.sched_proc is not None:
+            logger.info(f"Closing sched_ext scheduler '{self.old_sched}'.")
+            self.sched_proc.send_signal(signal.SIGINT)
+            self.sched_proc.wait()
+            self.sched_proc = None
+
+    def close(self):
+        self.close_sched()

adjustor-3.4.0/src/adjustor/drivers/general/settings.yml

@@ -0,0 +1,27 @@
+title: Power
+tags: [hide-title]
+type: container
+children:
+  profile:
+    type: multiple
+    # tags: [ordinal] # Steamdeck has issues with this
+    title: Power Profile
+    hint: >-
+      Allows setting the power profile of the system using Power Profiles Daemon.
+    options:
+      power-saver: Powersave
+      balanced: Balanced
+      performance: Performance
+    default: balanced
+  sched:
+    type: multiple
+    title: Custom Scheduler
+    hint: >-
+      Allows attaching a scheduler to the kernel sched_ext.
+      Schedulers need to be installed and kernel needs to support sched_ext.
+    options:
+      disabled: Disabled
+      scx_lavd: LAVD
+      scx_bpfland: bpfland 
+      scx_rusty: rusty
+    default: disabled

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/lenovo/__init__.py

@@ -165,6 +165,7 @@ class LenovoDriverPlugin(HHDPlugin):
             conf["tdp.lenovo.tdp.mode"] = mode
         elif new_mode:
             mode = new_mode
+            conf["tdp.lenovo.tdp.mode"] = mode
         else:
             mode = conf["tdp.lenovo.tdp.mode"].to(str)
         if mode is not None and mode != self.old_conf["tdp.mode"].to(str):

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/drivers/lenovo/settings.yml

@@ -10,16 +10,20 @@ children:
     modes:
       quiet:
         type: container
-        title: Quiet (8W)
+        title: Quiet
+        unit: 8W
       balanced:
         type: container
-        title: Balanced (15W)
+        title: Balanced
+        unit: 15W
       performance:
         type: container
-        title: Performance (20W)
+        title: Performance
+        unit: 20W
       custom:
         type: container
-        title: Custom (up to 25-30W)
+        title: Custom
+        unit: → 25/30W
         children:
           tdp:
             type: int
@@ -46,6 +50,12 @@ children:
             hint: >-
               Allows the device to boost by setting appropriate slow and fast TDPs.
   
+  cycle_info:
+    type: display
+    title: " "
+    tags: [non-essential]
+    default: "Legion L + Y changes TDP Mode"
+
   ffss:
     type: bool
     title: Set Fan to Full Speed

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor/hhd.py

@@ -256,7 +256,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
     default_tdp = 15
     max_tdp = 30
 
-    if prod == "83E1":
+    if prod == "83E1" and not bool(os.environ.get("HHD_ADJ_ALLY")):
         drivers.append(LenovoDriverPlugin())
         drivers_matched = True
         use_acpi_call = True
@@ -265,8 +265,9 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         "ROG Ally RC71L" in prod
         or "ROG Ally X RC72L" in prod
         or bool(os.environ.get("HHD_ADJ_DEBUG"))
+        or bool(os.environ.get("HHD_ADJ_ALLY"))
     ):
-        drivers.append(AsusDriverPlugin())
+        drivers.append(AsusDriverPlugin("RC72L" in prod))
         drivers_matched = True
 
     if os.environ.get("HHD_ADJ_DEBUG") or os.environ.get("HHD_ENABLE_SMU"):
@@ -322,8 +323,10 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
                 break
 
     if not drivers:
-        logger.info(f"No tdp drivers found for this device, exiting Adjustor.")
-        return []
+        from .drivers.general import GeneralPowerPlugin
+
+        logger.info(f"No tdp drivers found for this device, using generic plugin.")
+        return [GeneralPowerPlugin()]
 
     return [
         *drivers,

{adjustor-3.3.1 → adjustor-3.4.0/src/adjustor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.3.1
+Version: 3.4.0
 Summary: Adjustor, a userspace program for managing the TDP of handheld devices.
 Author-email: Kapenekakis Antheas <pypi@antheas.dev>
 Project-URL: Homepage, https://github.com/hhd-dev/adjustor
@@ -38,7 +38,7 @@ except intel handhelds and older prior to 6XXX AMD handhelds.
 ## TDP Control
 For the ROG Ally, Ally X and Legion Go that have an ACPI/EC implementation for 
 bios and fan curves,
-Adjustor uses the manufactuer functions for setting TDP.
+Adjustor uses the manufacturer functions for setting TDP.
 For the Allys, the asus-wmi kernel driver is used to set the tdp and manage the
 fan curves.
 For the Go, Lenovo's WMI methods are called through `acpi_call`, which will hopefully
@@ -53,14 +53,14 @@ For more, see [AMD TDP Control Details](#amd-tdp).
 In all cases, there are checks to ensure that the TDP is within the safe range
 of the processors.
 
-## Energy Management
-Adjustor can also manage the energy profile of the processor, by setting EPP
+## Energy Management in Handhelds
+Adjustor can also manage the energy profile of the processor in handhelds, by setting EPP
 and proper frequency values.
 After we transitioned people away from Decky plugins (which had some governor controls)
 to using Handheld Daemon for TDP, we found that Power Profiles Daemon (PPD) 
 would use aggressive CPU values.
 These values are optimized for devices that have a dedicated power budget for the CPU
-(e.g., laptops, desktops), which caused issues with handhelds.
+(e.g., laptops, desktops), which causes undesirable behavior handhelds.
 
 For example, the balanced PPD profile would set EPP to balance_performance and
 enable CPU boost, which would increase the draw of the CPU during gaming by 2W
@@ -91,6 +91,48 @@ TDP range instead of CPU values (which is the user's expectation).
 Of course, depending on TDP and user preference, the CPU governor values will be set
 accordingly.
 
+## Energy Management in other computers
+As we design Handheld Daemon to be enabled in more Deck style devices (e.g., HTPCs), 
+these devices have different power requirements and processors (e.g., Intel), which 
+are better managed with Power Profiles Daemon.
+It is the aim of the Handheld Daemon project to become a general Deck style session 
+manager for anything gamescope related, with useful features for all devices.
+
+In these cases, starting with 3.4, for devices that are not in the CPU/device
+whitelist (includes only AMD U series APUs and handhelds), Adjustor contains a 
+general energy management plugin that allows for switching the PPD power profile 
+from game mode.
+In addition, it supports [sched_ext schedulers](#sched_ext).
+
+This means that for general devices, Handheld Daemon uses PPD, and for handhelds,
+Handheld Daemon becomes PPD.
+This can be confusing for distribution maintainers and users, as they can and 
+should install both (e.g., Adjustor uses the Power Profile Daemon polkits).
+
+In any case, Adjustor will never break/conflict with PPD and contains helpful 
+messages about disabling PPD in case the optimized handheld plugin is loaded.
+For distribution maintainers that ship both and want Handheld Daemon to work
+without user intervention, the environment variable `HHD_PPD_MASK` is provided.
+If and only if it is set e.g., by using a systemd service extension, Handheld Daemon
+will mask and disable PPD if optimized energy management is supported and enabled (e.g., for handhelds).
+If the general plugin is loaded, it will unmask PPD during startup.
+This means that Power Management will work properly for all devices without manual
+intervention or whitelisting by distribution maintainers.
+
+## Sched_ext<a name="sched-ext"></a>
+Starting with version 3.3, Adjustor can attach sched_ext schedulers to the
+kernel if those are supported and installed.
+Adjustor manages the lifetime of the scheduler, including launching and attaching
+it, without using a systemd service, and is fully responsive to quirk scheduler
+switches.
+
+Schedulers are whitelisted in a case by case basis, with LAVD, rusty, and bpfland
+being supported in the current version (the `scx_` namespace is crowded with e.g.,
+test schedulers).
+Of course, only installed schedulers are shown if and only if the kernel supports
+them.
+Get in touch to add your favorite scheduler, as it is a single line change.
+
 ## AMD TDP Control Details<a name="amd-tdp"></a>
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface
 of AMD, which exposes a superset of the parameters that can be currently found in 
@@ -99,7 +141,7 @@ This vendor interface is part of the ACPI ASL library, and provided through the
 ALIB method 0x0C.
 The underlying implementation of the interface is SMU calls.
 This means that as long as the kernel module `acpi_call` is loaded, Adjustor
-can control TDP in an equivalent way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
+can control TDP in a similar way to [RyzenAdj](https://github.dev/FlyGoat/RyzenAdj/).
 
 The ABI of this vendor function (as it is provided to manufacturers) can be 
 considered mostly stable, so little work is needed between subsequent 
@@ -109,8 +151,9 @@ Of course, support for processors is only added after the ACPI bindings have
 been reviewed, to avoid surprises.
 Both the Ally and Legion Go use this function, in the exact same way, so setting
 TDP with it is very stable, and we have had no reported crashes.
-It should not be used (and is not used) with those devices, however, as the 
-manufacturer functions will interfere.
+It can not be used and is not used with those devices, however, as the 
+manufacturer functions would interfere and provide a better user experience,
+such as setting appropriate fan curves and changing the power light color on the Legion Go.
 
 Unfortunately for devices that do have an ACPI/EC implementation for TDP, there
 is no official way of setting TDP on demand, either on Linux or Windows, with

{adjustor-3.3.1 → adjustor-3.4.0}/src/adjustor.egg-info/SOURCES.txt

@@ -27,6 +27,8 @@ src/adjustor/drivers/amd/ppd.py
 src/adjustor/drivers/amd/settings.yml
 src/adjustor/drivers/asus/__init__.py
 src/adjustor/drivers/asus/settings.yml
+src/adjustor/drivers/general/__init__.py
+src/adjustor/drivers/general/settings.yml
 src/adjustor/drivers/lenovo/__init__.py
 src/adjustor/drivers/lenovo/settings.yml
 src/adjustor/drivers/smu/__init__.py