adjustor 3.5.1__tar.gz → 3.5.3__tar.gz

{adjustor-3.5.1/src/adjustor.egg-info → adjustor-3.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.5.1
+Version: 3.5.3
 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

{adjustor-3.5.1 → adjustor-3.5.3}/pyproject.toml

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

adjustor-3.5.3/src/adjustor/core/fan/__main__.py

@@ -0,0 +1,7 @@
+import sys
+
+from .core import fan_pwm_tester
+
+if __name__ == "__main__":
+    observe_only = "--observe" in sys.argv
+    fan_pwm_tester(observe_only=observe_only)

adjustor-3.5.3/src/adjustor/core/fan/alg.py

@@ -0,0 +1,157 @@
+# The objective of this fan algorithm is simple: receive a fan curve for a specific
+# power profile, the current system temperature, and the current fan speed.
+# Then, have a single variable memory: the current acceleration.
+# At each point, use a derived jerk to modify the acceleration and move the
+# speed to the desired point smoothly.
+
+# Maximum typical transition span of the fan speed (e.g., from 20% to 70%)
+# This transition span should take exactly the seconds specified below
+# E.g., if the fan begins to move from 20% to 70% with 0 acceleration, where
+# the temperature is at 70C, it should take at most 5 seconds.
+SPEED_SPAN = 0.5
+
+# The ratio of the curve to begin decelerating the fan change rpm/s^2
+# E.g., when going from 20% to 70%, the fan should begin decelerating
+# at 0.7*(70-20) + 20 = 62% speed.
+DECEL_RATIO = 0.5
+
+# The temperature at which the fan should use the high accel speed.
+HIGH_TEMP_EDGE = 65
+HIGH_TEMP_JUNCTION = 75
+
+# Allow for a gradual transition if the temperature is low
+# Speed up if not.
+ACCEL_UP_LOWT_T = 30
+ACCEL_UP_HIGH_T = 20
+# Penalize going down to avoid dithering
+ACCEL_DOWN_T = 40
+
+JERK_TOLERANCE = 0.9
+MAX_ACCEL = 0.4
+SETPOINT_DEVIATION = 0.01
+
+UPDATE_FREQUENCY = 5
+UPDATE_T = 1 / UPDATE_FREQUENCY
+SETPOINT_UPDATE_FREQUENCY = 1
+SETPOINT_UPDATE_T = 1 / SETPOINT_UPDATE_FREQUENCY
+HYSTERESIS_RATIO = 0.25
+
+
+def _calculate_jerk(speed_span, decel_ratio, freq, time):
+    """Calculate the required positive and negative jerks such that the
+    fan can cross the speed span (e.g., 50%) in the specified time (e.g., 5s)
+    given an update frequency (e.g., 3), and the point at which it should start
+    decelerating (e.g., 0.3).
+    """
+
+    jerk_accel = (2 * speed_span) / ((time * freq) ** 2) / ((1 - decel_ratio) ** 2)
+    jerk_decel = -(1 - decel_ratio) / decel_ratio * jerk_accel
+    return jerk_accel, jerk_decel
+
+
+def calculate_jerk(t_target: float, increase: bool, junction: bool):
+    """Calculate the jerk based on the target temperature and whether the fan
+    speed should increase or decrease to reach it.
+
+    Allow for specifying whether the temperature probe is in the junction or the
+    edge, as junction reaches thermal saturation faster and at higher temperatures."""
+    if not increase:
+        return _calculate_jerk(SPEED_SPAN, DECEL_RATIO, UPDATE_FREQUENCY, ACCEL_DOWN_T)
+
+    if (junction and t_target > HIGH_TEMP_JUNCTION) or (
+        not junction and t_target > HIGH_TEMP_EDGE
+    ):
+        return _calculate_jerk(
+            SPEED_SPAN, DECEL_RATIO, UPDATE_FREQUENCY, ACCEL_UP_HIGH_T
+        )
+
+    return _calculate_jerk(SPEED_SPAN, DECEL_RATIO, UPDATE_FREQUENCY, ACCEL_UP_LOWT_T)
+
+
+def move_to_setpoint(v_curr, a_curr, jerk_accel, jerk_decel, v_target):
+    """Update the current fan speed and acceleration by either using jerk_accel
+    which will increase acceleration to meet the target speed or jerk_decel
+    which will begin to decrease it to 0.
+
+    The choice between jerk_accel and jerk_decel is made by calculating the
+    minimum negative jerk required to decelerate to a=0 when reaching the target.
+    If the minimum jerk is smaller than jerk_decel, we use jerk_accel.
+    To avoid overshoots, a tolerance is used to start decelerating a bit earlier
+    than when the minimum jerk reaches the value of jerk_decel.
+    """
+
+    # Flip the jerks if the target is lower than the current speed
+    diff = v_target - v_curr
+    if diff < 0:
+        jerk_accel = -jerk_accel
+        jerk_decel = -jerk_decel
+
+    correct_direction = (diff > 0 and a_curr > 0) or (diff < 0 and a_curr < 0)
+    non_zero = abs(diff) > 1e-3
+
+    # Always accelerate if we are on the right direction or speed is zero
+    # Start decelerating once we run out of opposite jerk.
+    accel = True
+    if correct_direction and non_zero:
+        min_jerk_neg = -(a_curr**2) / 2 / diff
+        accel = abs(min_jerk_neg) < JERK_TOLERANCE * abs(jerk_decel)
+
+    if accel:
+        jerk = jerk_accel
+    else:
+        jerk = jerk_decel
+
+    # Calculate the new acceleration
+    a_new = a_curr + jerk
+    v_new = v_curr + a_new
+    return v_new, a_new
+
+
+def sanitize_fan_values(v: float, a: float):
+    return max(0, min(1, v)), max(-MAX_ACCEL, min(MAX_ACCEL, a))
+
+
+def has_reached_setpoint(v_curr, a_curr, v_target):
+    """Check if the current fan speed has reached the target speed.
+
+    If true, lower the update rate and set a_curr to 0 to avoid dithering.
+    """
+    return abs(v_curr - v_target) < SETPOINT_DEVIATION
+
+
+def update_setpoint(temp: float, curr: int, fan_curve: dict[int, float]):
+    """Update the setpoint given the current temperature, fan curve, and previous setpoint.
+
+    Fan curve is a dictionary of increasing temperatures to fan speeds.
+    """
+
+    targets = list(fan_curve.keys())
+    assert curr in targets, "Current setpoint not in fan curve"
+
+    idx = targets.index(curr)
+
+    # Add some hysterisis to avoid dithering
+    if idx > 0:
+        prev = targets[idx - 1]
+        if temp < prev + (curr - prev) * HYSTERESIS_RATIO:
+            return prev
+
+    if idx < len(targets) - 1:
+        next = targets[idx + 1]
+        if temp > next - (next - curr) * HYSTERESIS_RATIO:
+            return next
+
+    return curr
+
+
+def get_initial_setpoint(temp: float, fan_curve: dict[int, float]):
+    """Get the initial setpoint given the current temperature and fan curve.
+
+    Fan curve is a dictionary of increasing temperatures to fan speeds.
+    """
+
+    targets = list(fan_curve.keys())
+    for idx, target in enumerate(targets):
+        if temp < target:
+            return targets[idx - 1] if idx else targets[0]
+    return targets[-1]

adjustor-3.5.3/src/adjustor/core/fan/core.py

@@ -0,0 +1,194 @@
+import logging
+import time
+from typing import TypedDict
+
+from .alg import (
+    SETPOINT_UPDATE_T,
+    UPDATE_T,
+    calculate_jerk,
+    get_initial_setpoint,
+    has_reached_setpoint,
+    move_to_setpoint,
+    sanitize_fan_values,
+    update_setpoint,
+)
+from .utils import (
+    find_edge_temp,
+    find_fans,
+    find_tctl_temp,
+    read_fan_speed,
+    read_temp,
+    write_fan_speed,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class FanInfo(TypedDict):
+    tctl: str
+    edge: str
+    fans: list[str]
+
+
+class FanData(TypedDict):
+    a: float
+    v: float
+    t_target: int
+
+
+class FanState(TypedDict):
+    v_curr: float
+    v_target: float
+    v_target_pwm: int
+    v_rpm: list[int]
+    t_junction: float
+    t_edge: float
+    fan_data: FanData
+
+
+def get_fan_info() -> FanInfo | None:
+    tctl = find_tctl_temp()
+    if tctl is None:
+        logger.error("Could not find tctl junction temperature.")
+        return None
+
+    edge = find_edge_temp()
+    if edge is None:
+        logger.error("Could not find edge temperature.")
+        return None
+
+    fans = find_fans()
+    if not fans:
+        logger.error("Could not find PWM controllable fans.")
+        return None
+
+    return {"tctl": tctl, "edge": edge, "fans": fans}
+
+
+def calculate_fan_speed(
+    temp: float, data: FanData | None, fan_curve: dict[int, float], junction: bool
+) -> tuple[float, bool, FanData]:
+    if data is None:
+        # Initialize with best guess
+        t_target = get_initial_setpoint(temp, fan_curve)
+        v_curr = fan_curve[t_target]
+        a_curr = 0
+        return v_curr, False, {"a": a_curr, "v": v_curr, "t_target": t_target}
+
+    # Get values and new temp target setpoint
+    v_curr = data["v"]
+    a_curr = data["a"]
+    t_target = data["t_target"]
+    t_target = update_setpoint(temp, t_target, fan_curve)
+
+    # Pin values if we are in the setpoint
+    if has_reached_setpoint(v_curr, a_curr, fan_curve[t_target]):
+        a_curr = 0
+        v_curr = fan_curve[t_target]
+        return v_curr, True, {"a": a_curr, "v": v_curr, "t_target": t_target}
+
+    v_target = fan_curve[t_target]
+    jerk_accel, jerk_decel = calculate_jerk(t_target, v_target > v_curr, junction)
+    v_new, a_new = move_to_setpoint(v_curr, a_curr, jerk_accel, jerk_decel, v_target)
+    v_new, a_new = sanitize_fan_values(v_new, a_new)
+
+    return v_new, False, {"a": a_new, "v": v_new, "t_target": t_target}
+
+
+def set_fans_to_pwm(enable: bool, fan_info: FanInfo):
+    for _, fn_enable, _ in fan_info["fans"]:
+        with open(fn_enable, "w") as f:
+            f.write("1" if enable else "0")
+
+
+def update_fan_speed(
+    state: FanState | None,
+    fan_info: FanInfo,
+    fan_curve: dict[int, float],
+    junction: bool,
+    observe_only: bool = False,
+) -> tuple[bool, FanState]:
+    t_edge = read_temp(fan_info["edge"])
+    t_junction = read_temp(fan_info["tctl"])
+
+    t_curr = t_junction if junction else t_edge
+    data = state["fan_data"] if state else None
+    v_curr, in_setpoint, data = calculate_fan_speed(t_curr, data, fan_curve, junction)
+
+    v_curr_int = min(255, max(0, int(v_curr * 255)))
+    if not observe_only:
+        if state is None or state["v_target_pwm"] != v_curr_int:
+            for v_fn, _, _ in fan_info["fans"]:
+                write_fan_speed(v_fn, v_curr_int)
+
+    fan_speeds = [read_fan_speed(rpm_fn) for _, _, rpm_fn in fan_info["fans"] if rpm_fn]
+    return (
+        in_setpoint,
+        {
+            "v_curr": v_curr,
+            "v_target": fan_curve[data["t_target"]],
+            "v_target_pwm": v_curr_int,
+            "v_rpm": fan_speeds,
+            "t_junction": t_junction,
+            "t_edge": t_edge,
+            "fan_data": data,
+        },
+    )
+
+
+def fan_pwm_tester(normal_curve: bool = True, observe_only: bool = False):
+    fan_info = get_fan_info()
+    if fan_info is None:
+        return
+
+    if normal_curve:
+        fan_curve = {
+            50: 0.3,
+            60: 0.35,
+            70: 0.4,
+            80: 0.5,
+            85: 0.6,
+            90: 0.8,
+            100: 0.9,
+        }
+        fan_curve = {
+            40: 0.2,
+            45: 0.3,
+            50: 0.4,
+            55: 0.45,
+            60: 0.55,
+            65: 0.7,
+            70: 0.8,
+            80: 0.85,
+            90: 0.9,
+            100: 1,
+        }
+    else:
+        fan_curve = {
+            50: 0.3,
+            60: 0.3,
+            65: 0.9,
+            80: 0.9,
+            90: 0.9,
+            100: 1,
+        }
+
+    try:
+        if not observe_only:
+            set_fans_to_pwm(True, fan_info)
+
+        MAX_FAN = 5300
+
+        state = None
+        for i in range(10000000):
+            in_setpoint, state = update_fan_speed(state, fan_info, fan_curve, False, observe_only=observe_only)
+            
+            print(f"\n> {i:05d}: {'in setpoint' if in_setpoint else 'updating'}{' (observe)' if observe_only else ''}")
+            print(f"  Junction: {state['t_junction']:.2f}C, Edge: {state['t_edge']:.2f}C")
+            print(f"  Current: {state['v_curr']*100:.1f}%, Target: {state['v_target']*100:.1f}%")
+            print(f"  Fan speeds: {' '.join(map(lambda rpm: f"{rpm:4d}rpm/{MAX_FAN}rpm ({100*rpm/MAX_FAN:.1f}%)", state['v_rpm']))}")
+            time.sleep(SETPOINT_UPDATE_T if in_setpoint else UPDATE_T)
+    except KeyboardInterrupt:
+        print("Exiting fan test.")
+    finally:
+        set_fans_to_pwm(False, fan_info)

adjustor-3.5.3/src/adjustor/core/fan/utils.py

@@ -0,0 +1,93 @@
+import os
+
+FAN_HWMONS = ["oxpec"]
+HWMON_DIR = "/sys/class/hwmon"
+
+
+def get_hwmon():
+    for dir in os.listdir(HWMON_DIR):
+        if dir.startswith("hwmon"):
+            yield dir
+
+
+def find_edge_temp():
+    for hwmon in get_hwmon():
+        with open(f"{HWMON_DIR}/{hwmon}/name") as f:
+            name = f.read().strip()
+
+        if name != "amdgpu":
+            continue
+
+        # For sanity, check the device has CPUs to avoid hooking an eGPU.
+        if not os.path.exists(f"{HWMON_DIR}/{hwmon}/device/local_cpus"):
+            continue
+
+        if not os.path.exists(f"{HWMON_DIR}/{hwmon}/temp1_input"):
+            continue
+
+        return f"{HWMON_DIR}/{hwmon}/temp1_input"
+
+
+def find_tctl_temp():
+    for hwmon in get_hwmon():
+        with open(f"{HWMON_DIR}/{hwmon}/name") as f:
+            name = f.read().strip()
+
+        if name != "k10temp":
+            continue
+
+        # For sanity, check the device has CPUs to avoid hooking an eGPU.
+        if not os.path.exists(f"{HWMON_DIR}/{hwmon}/device/local_cpus"):
+            continue
+
+        if not os.path.exists(f"{HWMON_DIR}/{hwmon}/temp1_input"):
+            continue
+
+        return f"{HWMON_DIR}/{hwmon}/temp1_input"
+
+
+def find_fans():
+    """Finds tunable fans with endpoints pwmX and pwmX_enable."""
+    fans = []
+    for hwmon in get_hwmon():
+        with open(f"{HWMON_DIR}/{hwmon}/name") as f:
+            name = f.read().strip()
+
+        if name not in FAN_HWMONS:
+            continue
+
+        for fn in os.listdir(f"{HWMON_DIR}/{hwmon}"):
+            if (
+                fn.startswith("pwm")
+                and fn[3:].isdigit()
+                and os.path.exists(f"{HWMON_DIR}/{hwmon}/{fn}_enable")
+            ):
+                idx = fn[3:]
+                speed = f"fan{idx}_input"
+                if speed in os.listdir(f"{HWMON_DIR}/{hwmon}"):
+                    speed_fn = f"{HWMON_DIR}/{hwmon}/{speed}"
+                else:
+                    speed_fn = None
+                fans.append(
+                    (
+                        f"{HWMON_DIR}/{hwmon}/{fn}",
+                        f"{HWMON_DIR}/{hwmon}/{fn}_enable",
+                        speed_fn,
+                    )
+                )
+
+    return fans
+
+
+def read_temp(path: str) -> float:
+    with open(path, "r") as f:
+        return int(f.read()) / 1000
+
+
+def read_fan_speed(path: str) -> int:
+    with open(path, "r") as f:
+        return int(f.read())
+
+def write_fan_speed(path: str, speed: int):
+    with open(path, "w") as f:
+        f.write(str(speed))

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor/drivers/amd/__init__.py

@@ -142,11 +142,13 @@ class AmdGPUPlugin(HHDPlugin):
 
         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."
+                "PPD conflict detected but HHD_PPD_MASK is set. Masking PPD/TuneD."
             )
             # Mask and disable
             os.system("systemctl mask power-profiles-daemon.service")
             os.system("systemctl disable --now power-profiles-daemon.service")
+            os.system("systemctl mask tuned.service")
+            os.system("systemctl disable --now tuned.service")
             # Keep going without check to avoid obscure errors
             self.ppd_conflict = False
 
@@ -158,20 +160,20 @@ class AmdGPUPlugin(HHDPlugin):
             }
 
         self.initialized = True
-        
+
         # Initialize frequency settings
-        manual_freq = sets["enabled"]["children"]["mode"]["modes"]["manual"][
+        manual_freq = sets["enabled"]["children"]["gpu_freq"]["modes"]["manual"][
+            "children"
+        ]["frequency"]
+        upper_freq = sets["enabled"]["children"]["gpu_freq"]["modes"]["upper"][
             "children"
-        ]["gpu_freq"]["modes"]["manual"]["children"]["frequency"]
-        upper_freq = sets["enabled"]["children"]["mode"]["modes"]["manual"][
+        ]["frequency"]
+        min_freq = sets["enabled"]["children"]["gpu_freq"]["modes"]["range"][
             "children"
-        ]["gpu_freq"]["modes"]["upper"]["children"]["frequency"]
-        min_freq = sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
-            "gpu_freq"
-        ]["modes"]["range"]["children"]["min"]
-        max_freq = sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
-            "gpu_freq"
-        ]["modes"]["range"]["children"]["max"]
+        ]["min"]
+        max_freq = sets["enabled"]["children"]["gpu_freq"]["modes"]["range"][
+            "children"
+        ]["max"]
 
         manual_freq["default"] = ((status.freq_min + status.freq_max) // 200) * 100
         upper_freq["default"] = status.freq_max
@@ -285,6 +287,10 @@ class AmdGPUPlugin(HHDPlugin):
             if new_ppd:
                 try:
                     self.proc, self.t = _open_ppd_server(self.emit)
+                    # Fixup target in case it came before
+                    if self.proc.stdin and self.target:
+                        self.proc.stdin.write(f"{self.target}\n".encode())
+                        self.proc.stdin.flush()
                 except Exception as e:
                     logger.error(f"Failed to open PPD server:\n{e}")
                     self.close_ppd()
@@ -305,7 +311,6 @@ class AmdGPUPlugin(HHDPlugin):
                 try:
                     match self.target:
                         case "balanced":
-                            set_gpu_auto()
                             if self.supports_epp:
                                 set_powersave_governor()
                                 set_epp_mode("balance_power")
@@ -313,7 +318,6 @@ class AmdGPUPlugin(HHDPlugin):
                                 set_cpu_boost(True)
                             set_frequency_scaling(nonlinear=False)
                         case "performance":
-                            set_gpu_auto()
                             if self.supports_epp:
                                 set_powersave_governor()
                                 set_epp_mode("balance_power")
@@ -321,7 +325,6 @@ class AmdGPUPlugin(HHDPlugin):
                                 set_cpu_boost(True)
                             set_frequency_scaling(nonlinear=True)
                         case _:  # power
-                            set_gpu_auto()
                             if self.supports_epp:
                                 set_powersave_governor()
                                 set_epp_mode("power")
@@ -334,52 +337,11 @@ class AmdGPUPlugin(HHDPlugin):
             # Unless it is set manually, use the default scheduler.
             self.close_sched()
             self.old_sched = None
-            self.old_freq = None
             self.old_boost = None
             self.old_epp = None
             self.old_min_freq = None
         else:
             self.old_target = None
-            new_gpu = conf["tdp.amd_energy.mode.manual.gpu_freq.mode"].to(str)
-            match new_gpu:
-                case "manual":
-                    f = conf["tdp.amd_energy.mode.manual.gpu_freq.manual.frequency"].to(
-                        int
-                    )
-                    new_freq = (f, f)
-                case "upper":
-                    f = conf["tdp.amd_energy.mode.manual.gpu_freq.upper.frequency"].to(
-                        int
-                    )
-                    new_freq = (self.min_freq or f, f)
-                case "range":
-                    min_f = conf["tdp.amd_energy.mode.manual.gpu_freq.range.min"].to(
-                        int
-                    )
-                    max_f = conf["tdp.amd_energy.mode.manual.gpu_freq.range.max"].to(
-                        int
-                    )
-                    if max_f < min_f:
-                        max_f = min_f
-                        conf["tdp.amd_energy.mode.manual.gpu_freq.range.max"] = min_f
-                    new_freq = (min_f, max_f)
-                case _:
-                    new_freq = None
-
-            if new_freq != self.old_freq:
-                self.old_freq = new_freq
-                self.queue_gpu = curr + APPLY_DELAY
-
-            if self.queue_gpu is not None and curr >= self.queue_gpu:
-                self.queue_gpu = None
-                try:
-                    if new_freq:
-                        set_gpu_manual(*new_freq)
-                    else:
-                        set_gpu_auto()
-                except Exception as e:
-                    logger.error(f"Failed to set GPU mode:\n{e}")
-
             if self.supports_boost:
                 new_boost = conf["tdp.amd_energy.mode.manual.cpu_boost"].to(bool)
                 if new_boost != self.old_boost:
@@ -439,6 +401,39 @@ class AmdGPUPlugin(HHDPlugin):
                             stdout=subprocess.DEVNULL,
                         )
 
+        # Apply GPU settings
+        new_gpu = conf["tdp.amd_energy.gpu_freq.mode"].to(str)
+        match new_gpu:
+            case "manual":
+                f = conf["tdp.amd_energy.gpu_freq.manual.frequency"].to(int)
+                new_freq = (f, f)
+            case "upper":
+                f = conf["tdp.amd_energy.gpu_freq.upper.frequency"].to(int)
+                new_freq = (self.min_freq or f, f)
+            case "range":
+                min_f = conf["tdp.amd_energy.gpu_freq.range.min"].to(int)
+                max_f = conf["tdp.amd_energy.gpu_freq.range.max"].to(int)
+                if max_f < min_f:
+                    max_f = min_f
+                    conf["tdp.amd_energy.gpu_freq.range.max"] = min_f
+                new_freq = (min_f, max_f)
+            case _:
+                new_freq = None
+
+        if new_freq != self.old_freq:
+            self.old_freq = new_freq
+            self.queue_gpu = curr + APPLY_DELAY
+
+        if self.queue_gpu is not None and curr >= self.queue_gpu:
+            self.queue_gpu = None
+            try:
+                if new_freq:
+                    set_gpu_manual(*new_freq)
+                else:
+                    set_gpu_auto()
+            except Exception as e:
+                logger.error(f"Failed to set GPU mode:\n{e}")
+
     def close_ppd(self):
         if self.proc is not None:
             self.proc.send_signal(signal.SIGINT)

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor/drivers/amd/settings.yml

@@ -1,11 +1,11 @@
 enabled:
-  title: Energy Management
+  title: Processor Settings
   type: container
   tags: [ hide-title, non-essential ]
   children:
     mode:
       type: mode
-      title: Energy Management
+      title: CPU Settings
       default: auto
       modes:
         auto:
@@ -63,56 +63,6 @@ enabled:
               options:
                 disabled: Disabled
                 enabled: Enabled
-            gpu_freq:
-              type: mode
-              title: GPU Frequency
-              hint: >-
-                Pins the GPU to a certain frequency.
-                Helps in certain games that are CPU or GPU heavy
-                by shifting power to or from the GPU.
-                Has a minor effect.
-              default: auto
-              modes:
-                auto:
-                  type: container
-                  title: Auto
-                  hint: >-
-                    Lets the GPU manage its own frequency.
-                upper:
-                  type: container
-                  title: Upper Limit
-                  hint: >-
-                    Sets the GPU frequency to a maximum.
-                  children:
-                    frequency: &freq
-                      type: int
-                      unit: MHz
-                      min: 300
-                      max: 2000
-                      step: 100
-                      default: 1000
-                      title: Maximum Frequency
-                range:
-                  type: container
-                  title: Range
-                  hint: >-
-                    Sets the GPU frequency to a range.
-                  children:
-                    min:
-                      <<: *freq
-                      title: Minimum Frequency
-                    max:
-                      <<: *freq
-                      title: Maximum Frequency
-                manual:
-                  type: container
-                  title: Fixed
-                  hint: >-
-                    Sets the GPU frequency manually.
-                  children:
-                    frequency:
-                      <<: *freq
-                      title: Frequency
             sched:
               type: multiple
               title: Custom Scheduler
@@ -125,9 +75,59 @@ enabled:
                 scx_bpfland: bpfland 
                 scx_rusty: rusty
               default: disabled
+    gpu_freq:
+      type: mode
+      title: GPU Frequency
+      hint: >-
+        Pins the GPU to a certain frequency.
+        Helps in certain games that are CPU or GPU heavy
+        by shifting power to or from the GPU.
+        Has a minor effect.
+      default: auto
+      modes:
+        auto:
+          type: container
+          title: Auto
+          hint: >-
+            Lets the GPU manage its own frequency.
+        upper:
+          type: container
+          title: Max Limit
+          hint: >-
+            Limits the maximum frequency of the GPU.
+          children:
+            frequency: &freq
+              type: int
+              unit: MHz
+              min: 300
+              max: 2000
+              step: 100
+              default: 1000
+              title: Maximum Frequency
+        range:
+          type: container
+          title: Range
+          hint: >-
+            Sets the GPU frequency to a range.
+          children:
+            min:
+              <<: *freq
+              title: Minimum Frequency
+            max:
+              <<: *freq
+              title: Maximum Frequency
+        manual:
+          type: container
+          title: Fixed
+          hint: >-
+            Pins the GPU to a certain frequency (not recommended).
+          children:
+            frequency:
+              <<: *freq
+              title: Frequency
 
 conflict:
-  title: Energy Management
+  title: Processor Settings
   type: container
   tags: [ hide-title, non-essential ]
   children:
@@ -138,7 +138,7 @@ conflict:
         Energy Management can not be enabled while PPD or TuneD are enabled.
         `systemctl mask power-profiles-daemon` or `tuned`.
     enable:
-      title: Enable Energy Management
+      title: Enable Processor Settings
       type: action
       tags: [ non-essential ]
 core:

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor/drivers/asus/__init__.py

@@ -255,7 +255,6 @@ class AsusDriverPlugin(HHDPlugin):
         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.

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor/drivers/general/__init__.py

@@ -27,6 +27,7 @@ class GeneralPowerPlugin(HHDPlugin):
         self.old_sched = None
         self.sched_proc = None
         self.ppd_supported = None
+        self.tuned_supported = None
         self.is_steamdeck = is_steamdeck
         self.ovr_enabled = False
         self.should_exit = Event()
@@ -54,6 +55,26 @@ class GeneralPowerPlugin(HHDPlugin):
                 except Exception as e:
                     logger.warning(f"powerprofilectl returned with error:\n{e}")
 
+        # TuneD
+        if self.tuned_supported is None:
+            self.tuned_supported = False
+            if tuned := shutil.which('tuned-adm'):
+                try:
+                    if os.environ.get("HHD_PPD_MASK", None):
+                        logger.info("Unmasking TuneD in the case it was masked.")
+                        os.system('systemctl unmask tuned')
+                    subprocess.run(
+                        [tuned],
+                        check=True,
+                        stdin=subprocess.DEVNULL,
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    self.tuned_supported = True
+                except Exception as e:
+                    logger.warning(f"tuned-adm returned with error:\n{e}")
+
+
         if not self.ppd_supported:
             del sets["children"]["profile"]
 
@@ -122,6 +143,54 @@ class GeneralPowerPlugin(HHDPlugin):
                     logger.warning(f"powerprofilectl returned with error:\n{e}")
                     self.ppd_supported = False
 
+        # Handle TuneD
+        if self.tuned_supported:
+            curr = time.time()
+            ppd_tuned_mapping = {
+                "power-saver": "powersave",
+                "balanced": "balanced",
+                "performance": "throughput-performance"
+            }
+            new_profile = ppd_tuned_mapping.get(conf.get("tdp.general.profile", self.target))
+            if new_profile != self.target and new_profile and self.target:
+                logger.info(f"Setting TuneD profile to '{new_profile}'")
+                self.target = new_profile
+                try:
+                    subprocess.run(
+                        [shutil.which('tuned-adm'), "profile", new_profile],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                    )
+                except Exception as e:
+                    self.tuned_supported = False
+                    logger.warning(f"tuned-adm returned with error:\n{e}")
+                    self.tuned_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('tuned-adm'), "active"],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                    )
+
+                    tuned_ppd_mapping = {
+                        "powersave": "power-saver",
+                        "balanced": "balanced",
+                        "throughput-performance": "performance"
+                    }
+                    self.target = tuned_ppd_mapping.get(res.stdout.decode().split(":")[1].strip())  # type: ignore
+
+                    if self.target != conf["tdp.general.profile"].to(str):
+                        conf["tdp.general.profile"] = self.target
+                except Exception as e:
+                    self.tuned_supported = False
+                    logger.warning(f"powerprofilectl returned with error:\n{e}")
+                    self.tuned_supported = False
+
         # Handle sched
         if self.avail_scheds:
             # Check health and print error

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor/events.py

@@ -12,8 +12,12 @@ EVENT_MATCHES: Sequence[tuple[dict[str, Any], str]] = [
     ({"device_class": b"ac_adapter", "data": 0}, "dc"),
     ({"device_class": b"ac_adapter", "data": 256}, "ac"),
     ({"device_class": b"battery"}, "battery"),
+    ({"device_class": b"button/power"}, "powerbutton"),
     # Legion GO TDP event
     ({"bus_id": b"D320289E-8FEA-"}, "tdp"),
+    # GPD Force hibernate thermal event
+    # , 'type': 0xf100, 'data': 0x0100 ignore these attrs for now...
+    ({"device_class": b"thermal_zone", "bus_id": b"LNXTHERM:00"}, "hibernate-thermal"),
 ]
 
 GUARD_DELAY = 0.5
@@ -43,10 +47,10 @@ def loop_process_events(emit: Emitter, should_exit: TEvent):
                             break
 
                     if matches:
-                        if etype != "battery":
-                            emit({"type": "acpi", "event": etype}) # type: ignore
+                        if etype not in ("battery", "powerbutton"):
+                            emit({"type": "acpi", "event": etype})  # type: ignore
                         found = True
                         break
 
                 if not found:
-                    logger.info(f"Unknown ACPI event: {ev}")
+                    logger.info(f"ACPI event: {ev}")

{adjustor-3.5.1 → adjustor-3.5.3/src/adjustor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.5.1
+Version: 3.5.3
 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

{adjustor-3.5.1 → adjustor-3.5.3}/src/adjustor.egg-info/SOURCES.txt

@@ -20,6 +20,11 @@ src/adjustor/core/alib.py
 src/adjustor/core/const.py
 src/adjustor/core/lenovo.py
 src/adjustor/core/platform.py
+src/adjustor/core/fan/__init__.py
+src/adjustor/core/fan/__main__.py
+src/adjustor/core/fan/alg.py
+src/adjustor/core/fan/core.py
+src/adjustor/core/fan/utils.py
 src/adjustor/drivers/__init__.py
 src/adjustor/drivers/amd/__init__.py
 src/adjustor/drivers/amd/power-profiles-daemon.dbus.xml.in