adjustor 2.0.1__tar.gz → 2.1.0__tar.gz

{adjustor-2.0.1/src/adjustor.egg-info → adjustor-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 2.0.1
+Version: 2.1.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
@@ -29,11 +29,12 @@ setting TDP on demand in Ryzen processors, through ACPI.
 This means that it can be used regardless of the current memory policy
 or secure-boot/lockdown status (provided the module `acpi_call` is installed.).
 
-In addition, it fully implements Lenovo's WMI protocol for the Legion Go, allowing
-setting the TDP, including boosting behavior, without interference from
-the Embedded Computer.
-As part of the latest Lenovo bios, it also allows for setting a custom fan curve
-for the Legion Go.
+For the ROG Ally and Legion Go that have an ACPI/EC implementation for bios and fan curves,
+Adjustor uses the manufactuer way for setting TDP.
+For the ally, 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
+become part of a driver in the future.
 
 ## AMD TDP Control
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface

{adjustor-2.0.1 → adjustor-2.1.0}/pyproject.toml

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

{adjustor-2.0.1 → adjustor-2.1.0}/readme.md

@@ -11,11 +11,12 @@ setting TDP on demand in Ryzen processors, through ACPI.
 This means that it can be used regardless of the current memory policy
 or secure-boot/lockdown status (provided the module `acpi_call` is installed.).
 
-In addition, it fully implements Lenovo's WMI protocol for the Legion Go, allowing
-setting the TDP, including boosting behavior, without interference from
-the Embedded Computer.
-As part of the latest Lenovo bios, it also allows for setting a custom fan curve
-for the Legion Go.
+For the ROG Ally and Legion Go that have an ACPI/EC implementation for bios and fan curves,
+Adjustor uses the manufactuer way for setting TDP.
+For the ally, 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
+become part of a driver in the future.
 
 ## AMD TDP Control
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface

adjustor-2.1.0/src/adjustor/core/platform.py

@@ -0,0 +1,34 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_platform_choices():
+    try:
+        with open("/sys/firmware/acpi/platform_profile_choices", "r") as f:
+            return f.read().strip().split(" ")
+    except Exception:
+        logger.info(
+            f"Could not enumerate platform profile choices. Disabling platform profile."
+        )
+        return None
+
+
+def set_platform_profile(prof: str):
+    try:
+        logger.info(f"Setting platform profile to '{prof}'")
+        with open("/sys/firmware/acpi/platform_profile", "w") as f:
+            f.write(prof)
+        return True
+    except Exception as e:
+        logger.error(f"Could not set platform profile with error:\n{e}")
+        return False
+
+
+def get_platform_profile():
+    try:
+        with open("/sys/firmware/acpi/platform_profile", "r") as f:
+            return f.read().replace("\n", "")
+    except Exception as e:
+        logger.error(f"Could not read platform profile with error:\n{e}")
+        return None

adjustor-2.1.0/src/adjustor/drivers/asus/__init__.py

@@ -0,0 +1,256 @@
+import logging
+import time
+from typing import cast
+import os
+
+from hhd.plugins import Context, HHDPlugin, load_relative_yaml
+from hhd.plugins.conf import Config
+from adjustor.core.platform import get_platform_choices, set_platform_profile
+
+logger = logging.getLogger(__name__)
+
+APPLY_DELAY = 1.5
+TDP_DELAY = 0.2
+MIN_TDP_START = 7
+MAX_TDP_START = 30
+MAX_TDP = 54
+
+FTDP_FN = "/sys/devices/platform/asus-nb-wmi/ppt_fppt"
+STDP_FN = "/sys/devices/platform/asus-nb-wmi/ppt_pl2_sppt"
+CTDP_FN = "/sys/devices/platform/asus-nb-wmi/ppt_pl1_spl"
+
+FAN_CURVE_ENDPOINT = "/sys/class/hwmon"
+FAN_CURVE_NAME = "asus_custom_fan_curve"
+
+# Default Ally curve is the following
+# [40 45 55 63 68 74 74 74]
+# [10 20 66 86 132 188 188 188] / 2.55
+# [ 4  8  ]
+
+POINTS = [30, 40, 50, 60, 70, 80, 90, 100]
+MIN_CURVE = [2, 5, 17, 17, 17, 17, 17, 17]
+DEFAULT_CURVE = [5, 10, 20, 35, 55, 75, 75, 75]
+
+
+def set_tdp(pretty: str, fn: str, val: int):
+    logger.info(f"Setting tdp value '{pretty}' to {val} by writing to:\n{fn}")
+    try:
+        with open(fn, "w") as f:
+            f.write(f"{val}\n")
+        return True
+    except Exception as e:
+        logger.error(f"Failed writing value with error:\n{e}")
+        return False
+
+
+def find_fan_curve_dir():
+    for dir in os.listdir(FAN_CURVE_ENDPOINT):
+        name_fn = os.path.join(FAN_CURVE_ENDPOINT, dir, "name")
+        with open(name_fn, "r") as f:
+            name = f.read().strip()
+        if name == FAN_CURVE_NAME:
+            return os.path.join(FAN_CURVE_ENDPOINT, dir)
+    return None
+
+
+def set_fan_curve(points: list[int], curve: list[int]):
+    point_str = ",".join([f"{p:> 4d} C" for p in points])
+    curve_str = ",".join([f"{p:> 4d} /" for p in curve])
+    logger.info(f"Setting the following fan curve:\n{point_str}\n{curve_str} 255")
+
+    dir = find_fan_curve_dir()
+    if not dir:
+        logger.error(f"Could not find hwmon with name:\n'{FAN_CURVE_NAME}'")
+        return False
+
+    for fan in (1, 2):
+        for i, (temp, speed) in enumerate(zip(points, curve)):
+            with open(os.path.join(dir, f"pwm{fan}_auto_point{i+1}_temp"), "w") as f:
+                f.write(f"{temp}")
+            with open(os.path.join(dir, f"pwm{fan}_auto_point{i+1}_pwm"), "w") as f:
+                f.write(f"{speed}")
+
+    for fan in (1, 2):
+        with open(os.path.join(dir, f"pwm{fan}_enable"), "w") as f:
+            f.write(f"1")
+
+    return True
+
+
+def disable_fan_curve():
+    logger.info(f"Disabling custom fan curve.")
+
+    dir = find_fan_curve_dir()
+    if not dir:
+        logger.error(f"Could not find hwmon with name:\n'{FAN_CURVE_NAME}'")
+        return False
+
+    for fan in (1, 2):
+        with open(os.path.join(dir, f"pwm{fan}_enable"), "w") as f:
+            f.write(f"3")
+
+    return True
+
+
+class AsusDriverPlugin(HHDPlugin):
+    def __init__(self) -> None:
+        self.name = f"asus"
+        self.priority = 6
+        self.log = "adja"
+        self.enabled = False
+        self.initialized = False
+        self.enforce_limits = True
+        self.startup = True
+        self.old_conf = None
+
+        self.queue_fan = None
+        self.queue_tdp = None
+
+    def settings(self):
+        if not self.enabled:
+            self.initialized = False
+            self.old_conf = None
+            self.startup = True
+            return {}
+
+        self.initialized = True
+        out = {"tdp": {"asus": load_relative_yaml("settings.yml")}}
+        if not self.enforce_limits:
+            out["tdp"]["asus"]["children"]["tdp"]["max"] = 40
+        return out
+
+    def open(
+        self,
+        emit,
+        context: Context,
+    ):
+        pass
+
+    def update(self, conf: Config):
+        self.enabled = conf["hhd.settings.tdp_enable"].to(bool)
+        new_enforce_limits = conf["hhd.settings.enforce_limits"].to(bool)
+        new_lims = new_enforce_limits != self.enforce_limits
+        self.enforce_limits = new_enforce_limits
+
+        if not self.enabled or not self.initialized or new_lims:
+            self.old_conf = None
+            self.startup = True
+            return
+
+        # If not old config, exit, as values can not be set
+        if not self.old_conf:
+            self.old_conf = conf["tdp.asus"]
+            return
+
+        curr = time.time()
+
+        #
+        # TDP
+        #
+
+        # 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
+        steady = conf["tdp.asus.tdp"].to(int)
+
+        steady_updated = steady and steady != self.old_conf["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 = 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")
+            elif steady < 20:
+                set_platform_profile("balanced")
+            else:
+                set_platform_profile("performance")
+
+            self.queue_tdp = None
+            if boost:
+                set_tdp("steady", CTDP_FN, steady)
+                time.sleep(TDP_DELAY)
+                set_tdp("slow", STDP_FN, min(MAX_TDP, int(steady * 43 / 30)))
+                time.sleep(TDP_DELAY)
+                set_tdp("fast", FTDP_FN, min(MAX_TDP, int(steady * 53 / 30)))
+            else:
+                set_tdp("steady", CTDP_FN, steady)
+                time.sleep(TDP_DELAY)
+                set_tdp("slow", STDP_FN, steady)
+                time.sleep(TDP_DELAY)
+                set_tdp("fast", FTDP_FN, steady)
+
+        # Handle fan curve resets
+        if conf["tdp.asus.fan.manual.reset"].to(bool):
+            conf["tdp.asus.fan.manual.reset"] = False
+            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
+
+        # Check if fan curve has changed
+        # Use debounce logic on these changes
+        if tdp_set and conf["tdp.asus.fan.mode"].to(str) == "manual":
+            self.queue_fan = curr + APPLY_DELAY
+        if conf["tdp.asus.fan.mode"].to(str) != self.old_conf["fan.mode"].to(str):
+            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}"
+            ].to(int):
+                self.queue_fan = curr + APPLY_DELAY
+
+        apply_curve = self.queue_fan and self.queue_fan < curr
+        if apply_curve:
+            try:
+                # Always disable fan curve first
+                disable_fan_curve()
+                if conf["tdp.asus.fan.mode"].to(str) == "manual":
+                    time.sleep(TDP_DELAY)
+                    set_fan_curve(
+                        POINTS,
+                        [
+                            min(
+                                int(conf[f"tdp.asus.fan.manual.st{i}"].to(int) * 2.55),
+                                255,
+                            )
+                            for i in POINTS
+                        ],
+                    )
+            except Exception as e:
+                logger.error(f"Could not set fan curve. Error:\n{e}")
+            self.queue_fan = None
+
+        # Save current config
+        self.old_conf = conf["tdp.asus"]
+
+        if self.startup:
+            self.startup = False
+
+    def close(self):
+        pass

adjustor-2.1.0/src/adjustor/drivers/asus/settings.yml

@@ -0,0 +1,99 @@
+title: Asus TDP
+type: container
+tags: [hide-title]
+hint: >-
+  Uses the interface of Legion Space 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.
+      If it is not, it sets the Slow limit equal to TDP and the Fast
+      limit to +2W.
+      Boost is recommended for desktop use.
+
+    min: 5
+    max: 30
+    step: 1
+    default: 30
+    unit: W
+  boost:
+    type: bool
+    title: TDP Boost
+    default: True
+    hint: >-
+      Allows the device to boost by setting appropriate slow and fast TDPs.
+
+  fan:
+    type: mode
+    title: Custom Fan Curve
+    hint: >-
+      Allows you to set a custom fan curve.
+    default: disabled
+    modes:
+      disabled:
+        type: container
+        title: Disabled
+        hint: >-
+          Lets the device manage the fan curve on its own.
+      manual:
+        type: container
+        title: Manual [BETA]
+        tags: [ non-essential ]
+        children:
+
+          st30: &speed_template
+            title: 30C
+            hint: Sets the speed at the named temperature.
+            tags: [slim]
+            type: int
+            min: 0
+            default: 5
+            max: 100
+            step: 2
+            unit: "%"
+            
+          st40:
+            <<: *speed_template
+            title: 40C
+            default: 10
+          st50:
+            <<: *speed_template
+            title: 50C
+            default: 20
+          st60:
+            <<: *speed_template
+            title: 60C
+            default: 35
+          st70:
+            <<: *speed_template
+            title: 70C
+            default: 55
+          st80:
+            <<: *speed_template
+            title: 80C
+            default: 75
+          st90:
+            <<: *speed_template
+            title: 90C
+            default: 75
+          st100:
+            <<: *speed_template
+            title: 100C
+            default: 75
+
+          enforce_limits:
+            title: Enforce Minimums
+            type: bool
+            default: True
+            hint: >-
+              Enforce a reasonable minimum fan curve.
+            
+          reset:
+            title: Restore Default
+            type: action
+            hint: >-
+              Restore a default sane fan curve.

{adjustor-2.0.1 → adjustor-2.1.0}/src/adjustor/drivers/smu/__init__.py

@@ -5,40 +5,10 @@ from hhd.plugins import Context, HHDPlugin, load_relative_yaml
 from hhd.plugins.conf import Config
 
 from adjustor.core.alib import AlibParams, DeviceParams, alib
+from adjustor.core.platform import get_platform_choices, set_platform_profile
 
 logger = logging.getLogger(__name__)
 
-
-def get_platform_choices():
-    try:
-        with open("/sys/firmware/acpi/platform_profile_choices", "r") as f:
-            return f.read().strip().split(" ")
-    except Exception:
-        logger.info(
-            f"Could not enumerate platform profile choices. Disabling platform profile."
-        )
-        return None
-
-
-def set_platform_profile(prof: str):
-    try:
-        with open("/sys/firmware/acpi/platform_profile", "w") as f:
-            f.write(prof)
-        return True
-    except Exception as e:
-        logger.error(f"Could not set platform profile with error:\n{e}")
-        return False
-
-
-def get_platform_profile():
-    try:
-        with open("/sys/firmware/acpi/platform_profile", "r") as f:
-            return f.read().replace("\n", "")
-    except Exception as e:
-        logger.error(f"Could not read platform profile with error:\n{e}")
-        return None
-
-
 PP_DELAY = 0.2
 APPLY_DELAY = 1
 

{adjustor-2.0.1 → adjustor-2.1.0}/src/adjustor/hhd.py

@@ -79,7 +79,7 @@ class AdjustorInitPlugin(HHDPlugin):
                 return
 
         initialize()
-        if  not check_perms():
+        if not check_perms():
             conf["hhd.settings.tdp_enable"] = False
             conf["tdp.tdp.tdp_error"] = (
                 "Can not write to 'acpi_call'. It is required for TDP."
@@ -168,6 +168,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         return existing
 
     from .drivers.lenovo import LenovoDriverPlugin
+    from .drivers.asus import AsusDriverPlugin
     from .drivers.smu import SmuDriverPlugin, SmuQamPlugin
 
     drivers = []
@@ -181,6 +182,10 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         drivers.append(LenovoDriverPlugin())
         drivers_matched = True
 
+    if "ROG Ally RC71L" in prod:
+        drivers.append(AsusDriverPlugin())
+        drivers_matched = True
+
     if os.environ.get("HHD_ADJ_DEBUG") or os.environ.get("HHD_ENABLE_SMU"):
         drivers_matched = False
 

{adjustor-2.0.1 → adjustor-2.1.0/src/adjustor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 2.0.1
+Version: 2.1.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
@@ -29,11 +29,12 @@ setting TDP on demand in Ryzen processors, through ACPI.
 This means that it can be used regardless of the current memory policy
 or secure-boot/lockdown status (provided the module `acpi_call` is installed.).
 
-In addition, it fully implements Lenovo's WMI protocol for the Legion Go, allowing
-setting the TDP, including boosting behavior, without interference from
-the Embedded Computer.
-As part of the latest Lenovo bios, it also allows for setting a custom fan curve
-for the Legion Go.
+For the ROG Ally and Legion Go that have an ACPI/EC implementation for bios and fan curves,
+Adjustor uses the manufactuer way for setting TDP.
+For the ally, 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
+become part of a driver in the future.
 
 ## AMD TDP Control
 Adjustor controls TDP through the Dynamic Power and Thermal Configuration Interface

{adjustor-2.0.1 → adjustor-2.1.0}/src/adjustor.egg-info/SOURCES.txt

@@ -14,12 +14,15 @@ src/adjustor.egg-info/dependency_links.txt
 src/adjustor.egg-info/entry_points.txt
 src/adjustor.egg-info/requires.txt
 src/adjustor.egg-info/top_level.txt
+src/adjustor/core/__init__.py
 src/adjustor/core/acpi.py
 src/adjustor/core/alib.py
-src/adjustor/core/asus.py
 src/adjustor/core/const.py
 src/adjustor/core/lenovo.py
+src/adjustor/core/platform.py
 src/adjustor/drivers/__init__.py
+src/adjustor/drivers/asus/__init__.py
+src/adjustor/drivers/asus/settings.yml
 src/adjustor/drivers/lenovo/__init__.py
 src/adjustor/drivers/lenovo/settings.yml
 src/adjustor/drivers/smu/__init__.py

adjustor-2.0.1/src/adjustor/core/asus.py

@@ -1,50 +0,0 @@
-from .acpi import call, read
-from typing import Sequence, Literal
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-POINTS = [
-    30,
-    40,
-    50,
-    60,
-    70,
-    80,
-    90,
-    90,
-]
-
-MIN_CURVE = [
-    30,
-    30,
-    30,
-    45,
-    50,
-    50,
-    50,
-    50,
-]
-
-
-def write_fan_curve(arr: list[int]):
-    logger.info(f"Setting fan curve to:\n{arr}")
-    if len(arr) != 8:
-        logger.error(f"Invalid fan curve length: {len(arr)}. Should be 10.")
-        return False
-    if any(not isinstance(d, int) or d > 100 for d in arr):
-        logger.error(f"Curve has null value or higher than 100, not setting.")
-        return False
-
-    for c in (0x00110024, 0x00110025):
-        call(
-            r" \_SB_.ATKD.WMNB",
-            [
-                0,
-                0x53564544,
-                int.to_bytes(c, length=4, byteorder="little", signed=False)
-                + bytes(POINTS)
-                + bytes(arr),
-            ],
-        )