adjustor 3.5.2__tar.gz → 3.5.4__tar.gz

{adjustor-3.5.2/src/adjustor.egg-info → adjustor-3.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.5.2
+Version: 3.5.4
 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.2 → adjustor-3.5.4}/pyproject.toml

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

{adjustor-3.5.2 → adjustor-3.5.4}/src/adjustor/core/const.py

@@ -1,5 +1,33 @@
+from typing import TypedDict
+
 from .alib import A, D, DeviceParams, AlibParams
 
+
+class DevicePreset(TypedDict):
+    tdp_limit: int
+    slow_limit: int
+    fast_limit: int
+    slow_time: int
+    stapm_time: int
+    temp_target: int
+    fan_curve: dict[int, float] | None
+
+
+class DevideProfile(TypedDict):
+    quiet: DevicePreset
+    balanced: DevicePreset
+    performance: DevicePreset
+    # Turbo is custom with max tdp values
+    turbo: DevicePreset
+
+    platform_profile_map: dict[str, int]
+    ppd_balanced_min: int
+    ppd_performance_min: int
+
+    alib: dict[str, AlibParams]
+    dev: dict[str, DeviceParams]
+
+
 PLATFORM_PROFILE_MAP = [
     ("low-power", 0),
     ("quiet", 0),
@@ -29,6 +57,7 @@ ALIB_PARAMS_5040: dict[str, AlibParams] = ALIB_PARAMS
 ALIB_PARAMS_7040: dict[str, AlibParams] = ALIB_PARAMS
 ALIB_PARAMS_6040: dict[str, AlibParams] = ALIB_PARAMS
 ALIB_PARAMS_8040: dict[str, AlibParams] = ALIB_PARAMS
+ALIB_PARAMS_HX370: dict[str, AlibParams] = ALIB_PARAMS
 
 DEV_PARAMS_30W: dict[str, DeviceParams] = {
     "stapm_limit": D(0, 4, 15, 30, 40),
@@ -69,12 +98,14 @@ DEV_PARAMS_5000: dict[str, DeviceParams] = DEV_PARAMS_25W
 DEV_PARAMS_6000: dict[str, DeviceParams] = DEV_PARAMS_30W
 DEV_PARAMS_7040: dict[str, DeviceParams] = DEV_PARAMS_30W
 DEV_PARAMS_8040: dict[str, DeviceParams] = DEV_PARAMS_30W
+DEV_PARAMS_HX370: dict[str, DeviceParams] = DEV_PARAMS_30W
 DEV_PARAMS_LEGO = DEV_PARAMS_30W
 
 DEV_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams], bool]] = {
     "NEO-01": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
     "V3": (DEV_PARAMS_28W, ALIB_PARAMS_8040, False),
     "83E1": (DEV_PARAMS_LEGO, ALIB_PARAMS_7040, False),
+    "ONEXPLAYER F1Pro": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, False),
 }
 
 CPU_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams]]] = {
@@ -88,4 +119,5 @@ CPU_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams]]] = {
     "AMD Ryzen 7 7840U": (DEV_PARAMS_7040, ALIB_PARAMS_7040),
     "AMD Ryzen 7 8840U": (DEV_PARAMS_8040, ALIB_PARAMS_8040),
     # AMD Athlon Silver 3050e (Win600, will it support tdp?)
+    "AMD Ryzen AI 9 HX 370": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370),
 }

adjustor-3.5.4/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.4/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.4/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.4/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.2 → adjustor-3.5.4}/src/adjustor/drivers/amd/__init__.py

@@ -160,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
@@ -287,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()
@@ -307,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")
@@ -315,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")
@@ -323,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")
@@ -336,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:
@@ -441,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.2 → adjustor-3.5.4}/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.2 → adjustor-3.5.4}/src/adjustor/drivers/asus/__init__.py

@@ -225,7 +225,7 @@ class AsusDriverPlugin(HHDPlugin):
             lim != self.old_conf["charge_limit"].to(str)
         ):
             self.queue_charge_limit = curr + APPLY_DELAY
-        
+
         if self.queue_charge_limit and self.queue_charge_limit < curr:
             self.queue_charge_limit = None
             match lim:
@@ -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.
@@ -282,6 +281,9 @@ class AsusDriverPlugin(HHDPlugin):
                 self.sys_tdp = False
             tdp_reset = True
 
+        if mode is not None and self.startup:
+            tdp_reset = True
+
         # Handle EPP for presets
         if tdp_reset and mode != "custom":
             match mode:

{adjustor-3.5.2 → adjustor-3.5.4}/src/adjustor/drivers/general/__init__.py

@@ -64,7 +64,7 @@ class GeneralPowerPlugin(HHDPlugin):
                         logger.info("Unmasking TuneD in the case it was masked.")
                         os.system('systemctl unmask tuned')
                     subprocess.run(
-                        [tuned],
+                        [tuned,'active'],
                         check=True,
                         stdin=subprocess.DEVNULL,
                         stdout=subprocess.DEVNULL,
@@ -75,7 +75,7 @@ class GeneralPowerPlugin(HHDPlugin):
                     logger.warning(f"tuned-adm returned with error:\n{e}")
 
 
-        if not self.ppd_supported:
+        if not self.ppd_supported and not self.tuned_supported:
             del sets["children"]["profile"]
 
         # SchedExt
@@ -188,7 +188,7 @@ class GeneralPowerPlugin(HHDPlugin):
                         conf["tdp.general.profile"] = self.target
                 except Exception as e:
                     self.tuned_supported = False
-                    logger.warning(f"powerprofilectl returned with error:\n{e}")
+                    logger.warning(f"tuned-adm returned with error:\n{e}")
                     self.tuned_supported = False
 
         # Handle sched

{adjustor-3.5.2 → adjustor-3.5.4}/src/adjustor/drivers/lenovo/__init__.py

@@ -44,6 +44,7 @@ class LenovoDriverPlugin(HHDPlugin):
         self.old_conf = None
         self.sys_tdp = False
         self.fan_curve_set = False
+        self.notify_tdp = False
 
         bios_version = get_bios_version()
         logger.info(f"Lenovo BIOS version: {bios_version}")
@@ -326,6 +327,12 @@ class LenovoDriverPlugin(HHDPlugin):
         # Save current config
         self.old_conf = conf["tdp.lenovo"]
 
+        if self.notify_tdp:
+            self.notify_tdp = False
+            print(new_mode)
+            if conf.get("tdp.lenovo.tdp_rgb", False):
+                self.emit({"type": "special", "event": f"tdp_cycle_{new_mode}"})  # type: ignore
+
         if self.startup:
             self.startup = False
 
@@ -333,7 +340,7 @@ class LenovoDriverPlugin(HHDPlugin):
         for ev in events:
             if ev["type"] == "tdp":
                 self.new_tdp = ev["tdp"]
-                self.sys_tdp = ev['tdp'] is not None
+                self.sys_tdp = ev["tdp"] is not None
             if ev["type"] == "ppd":
                 match ev["status"]:
                     case "power":
@@ -342,6 +349,9 @@ class LenovoDriverPlugin(HHDPlugin):
                         self.new_mode = "balanced"
                     case "performance":
                         self.new_mode = "performance"
+            print(ev)
+            if ev["type"] == "acpi" and ev.get("event", None) == "tdp":
+                self.notify_tdp = True
 
     def close(self):
         pass

{adjustor-3.5.2 → adjustor-3.5.4}/src/adjustor/drivers/lenovo/settings.yml

@@ -143,6 +143,12 @@ children:
             hint: >-
               Reset to the original fan curve provided by Lenovo in BIOS V28.
 
+  tdp_rgb:
+    type: bool
+    title: Show TDP changes with RGB
+    tags: [non-essential]
+    default: False
+
   charge_limit:
     tags: [advanced]
     type: bool

{adjustor-3.5.2 → adjustor-3.5.4}/src/adjustor/events.py

@@ -12,8 +12,13 @@ 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"),
+    ({"device_class": b"wmi", "bus_id": b"PNP0C14:01"}, "tdp"), # Legion go
+    # 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 +48,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.2 → adjustor-3.5.4/src/adjustor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.5.2
+Version: 3.5.4
 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.2 → adjustor-3.5.4}/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