adjustor 3.2.1__tar.gz → 3.3.1__tar.gz

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

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

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

{adjustor-3.2.1 → adjustor-3.3.1}/src/adjustor/core/const.py

@@ -41,12 +41,25 @@ DEV_PARAMS_7040: dict[str, DeviceParams] = {
     "temp_target": D(60, 70, 85, 90, 100),
 }
 
+DEV_PARAMS_28W: dict[str, DeviceParams] = {
+    "stapm_limit": D(0, 4, 15, 28, 35),
+    "skin_limit": D(0, 4, 15, 28, 35),
+    "slow_limit": D(0, 4, 20, 32, 37),
+    "fast_limit": D(0, 4, 25, 35, 40),
+    # Times
+    "slow_time": D(5, 5, 10, 10, 10),
+    "stapm_time": D(100, 100, 100, 200, 200),
+    # Temp
+    "temp_target": D(60, 70, 85, 90, 100),
+}
+
 DEV_PARAMS_6040: dict[str, DeviceParams] = DEV_PARAMS_7040
 DEV_PARAMS_8040: dict[str, DeviceParams] = DEV_PARAMS_7040
 DEV_PARAMS_LEGO = DEV_PARAMS_7040
 
 DEV_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams], bool]] = {
-    "NEO-01": (DEV_PARAMS_7040, ALIB_PARAMS_7040, False),
+    "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),
 }
 

{adjustor-3.2.1 → adjustor-3.3.1}/src/adjustor/core/lenovo.py

@@ -104,12 +104,12 @@ def set_fan_curve(arr: Sequence[int], lim: Sequence[int] | None = None):
     )
 
 
-def set_power_light(enabled: bool):
+def set_power_light_v1(enabled: bool):
     logger.debug(f"Setting power light status.")
     return call(r"\_SB.GZFD.WMAF", [0, 0x02, bytes([0x03, int(enabled), 0x00])])
 
 
-def get_power_light():
+def get_power_light_v1():
     logger.debug(f"Getting power light status.")
     if not call(r"\_SB.GZFD.WMAF", [0, 0x01, 0x03], risky=False):
         return None
@@ -119,6 +119,42 @@ def get_power_light():
     return None
 
 
+def set_power_light(enabled: bool, suspend: bool = False):
+    logger.debug(f"Setting power light status.")
+    if enabled:
+        if suspend:
+            cb = 0x03
+        else:
+            cb = 0x02
+    else:
+        cb = 0x01
+    return call(
+        r"\_SB.GZFD.WMAF",
+        [0, 0x02, bytes([0x024 if suspend else 0x04, 0x00, cb])],
+    )
+
+
+def get_power_light(suspend: bool = False):
+    logger.debug(f"Getting power light status.")
+    if not call(r"\_SB.GZFD.WMAF", [0, 0x01, 0x024 if suspend else 0x04], risky=False):
+        return None
+    o = read()
+    if isinstance(o, bytes) and len(o) == 2:
+        return o[1] == (0x03 if suspend else 0x02)
+    return None
+
+
+def get_bios_version():
+    raw = None
+    try:
+        with open("/sys/class/dmi/id/bios_version") as f:
+            raw = f.read()
+        return int(raw.replace("N3CN", "").split("WW")[0].strip())
+    except Exception as e:
+        logger.error(f"Failed to get BIOS version from '{raw}' with error:\n{e}")
+        return 1
+
+
 def get_feature(id: int):
     if not call(
         r"\_SB.GZFD.WMAE",

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

@@ -2,10 +2,11 @@ import logging
 import os
 import subprocess
 import sys
-from threading import Event as TEvent
 from threading import Thread
 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
@@ -67,14 +68,18 @@ class AmdGPUPlugin(HHDPlugin):
         self.ppd_conflict = False
         self.initialized = False
         self.supports_boost = False
+        self.supports_sched = False
+        self.avail_scheds = {}
 
         self.proc = None
         self.t = None
 
         self.queue = None
+        self.sched_proc = None
         self.old_ppd = False
         self.old_gpu = None
         self.old_freq = None
+        self.old_sched = "disabled"
         self.old_boost = None
         self.old_epp = None
         self.old_target = None
@@ -174,6 +179,31 @@ class AmdGPUPlugin(HHDPlugin):
                 "cpu_pref"
             ]
 
+        self.avail_scheds = {}
+        avail_pretty = {}
+        kernel_supports = os.path.isfile("/sys/kernel/sched_ext/state")
+        if kernel_supports:
+            for sched, pretty in sets["enabled"]["children"]["mode"]["modes"]["manual"][
+                "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["enabled"]["children"]["mode"]["modes"]["manual"]["children"]["sched"][
+                "options"
+            ] = avail_pretty
+        else:
+            del sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
+                "sched"
+            ]
+
         self.logged_boost = True
         return {
             "tdp": {"amd_energy": sets["enabled"]},
@@ -197,7 +227,7 @@ class AmdGPUPlugin(HHDPlugin):
                         self.proc.stdin.flush()
                 except Exception as e:
                     logger.error(f"Failed to send PPD mode:\n{e}")
-                    self.close()
+                    self.close_ppd()
 
     def update(self, conf: Config):
         self.core_enabled = conf["hhd.settings.tdp_enable"].to(bool)
@@ -224,9 +254,9 @@ class AmdGPUPlugin(HHDPlugin):
                     self.proc, self.t = _open_ppd_server(self.emit)
                 except Exception as e:
                     logger.error(f"Failed to open PPD server:\n{e}")
-                    self.close()
+                    self.close_ppd()
             else:
-                self.close()
+                self.close_ppd()
 
         if conf["tdp.amd_energy.mode.mode"].to(str) == "auto":
             curr = time.perf_counter()
@@ -239,6 +269,8 @@ class AmdGPUPlugin(HHDPlugin):
                 logger.info(
                     f"Handling energy settings for power profile '{self.target}'."
                 )
+                # Unless it is set manually, use the default scheduler.
+                self.close_sched()
                 try:
                     match self.target:
                         case "balanced":
@@ -329,10 +361,43 @@ class AmdGPUPlugin(HHDPlugin):
                     except Exception as e:
                         logger.error(f"Failed to set minimum CPU frequency:\n{e}")
 
-    def close(self):
+            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.amd_energy.mode.manual.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_ppd(self):
         if self.proc is not None:
-            self.proc.terminate()
+            self.proc.send_signal(signal.SIGINT)
             self.proc.wait()
+            self.proc = None
         if self.t is not None:
             self.t.join()
             self.t = None
+
+    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_ppd()
+        self.close_sched()

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

@@ -87,6 +87,18 @@ enabled:
                       max: 2000
                       step: 100
                       default: 1000
+            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
 
 conflict:
   title: Energy Management

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

@@ -20,6 +20,9 @@ from adjustor.core.lenovo import (
     set_slow_tdp,
     set_steady_tdp,
     set_tdp_mode,
+    get_bios_version,
+    get_power_light_v1,
+    set_power_light_v1,
 )
 
 logger = logging.getLogger(__name__)
@@ -40,6 +43,10 @@ class LenovoDriverPlugin(HHDPlugin):
         self.old_conf = None
         self.fan_curve_set = False
 
+        bios_version = get_bios_version()
+        logger.info(f"Lenovo BIOS version: {bios_version}")
+        self.power_light_v2 = bios_version >= 35
+
         self.queue_fan = None
         self.queue_tdp = None
         self.new_tdp = None
@@ -55,6 +62,8 @@ class LenovoDriverPlugin(HHDPlugin):
 
         self.initialized = True
         out = {"tdp": {"lenovo": load_relative_yaml("settings.yml")}}
+        if not self.power_light_v2:
+            del out["tdp"]["lenovo"]["children"]["power_light_sleep"]
         if not self.enforce_limits:
             out["tdp"]["lenovo"]["children"]["tdp"]["modes"]["custom"]["children"][
                 "tdp"
@@ -88,7 +97,12 @@ class LenovoDriverPlugin(HHDPlugin):
         tdp_reset = self.startup
         if self.startup:
             conf["tdp.lenovo.ffss"] = get_full_fan_speed()
-            conf["tdp.lenovo.power_light"] = get_power_light()
+            if self.power_light_v2:
+                conf["tdp.lenovo.power_light"] = get_power_light(suspend=False)
+                conf["tdp.lenovo.power_light_sleep"] = get_power_light(suspend=True)
+            else:
+                conf["tdp.lenovo.power_light"] = get_power_light_v1()
+
             conf["tdp.lenovo.charge_limit"] = get_charge_limit()
 
         # If not old config, exit, as values can not be set
@@ -109,7 +123,17 @@ class LenovoDriverPlugin(HHDPlugin):
         if power_light is not None and power_light != self.old_conf["power_light"].to(
             bool
         ):
-            set_power_light(power_light)
+            if self.power_light_v2:
+                set_power_light(power_light, suspend=False)
+            else:
+                set_power_light_v1(power_light)
+        if self.power_light_v2:
+            power_light_sleep = conf["tdp.lenovo.power_light_sleep"].to(bool)
+            if (
+                power_light_sleep != self.old_conf["power_light_sleep"].to(bool)
+                and power_light_sleep is not None
+            ):
+                set_power_light(power_light_sleep, suspend=True)
 
         charge_limit = conf["tdp.lenovo.charge_limit"].to(bool)
         if charge_limit is not None and charge_limit != self.old_conf[

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

@@ -137,11 +137,16 @@ children:
   charge_limit:
     tags: [advanced]
     type: bool
-    title: Enable Charge Limit (80%)
+    title: Charge Limit (80%)
     hint: >-
       Limits device charging to 80%. Lenovo EC method. Available since BIOSv29.
 
   power_light:
     tags: [advanced]
     type: bool
-    title: Enable Power Light
+    title: Power Light (Awake)
+
+  power_light_sleep:
+    tags: [advanced]
+    type: bool
+    title: Power Light (Sleep)

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

@@ -274,6 +274,18 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
 
     if not drivers_matched and prod in DEV_DATA:
         dev, cpu, pp_enable = DEV_DATA[prod]
+
+        try:
+            # Set values for the steam slider
+            if dev["skin_limit"].smin:
+                min_tdp = dev["skin_limit"].smin
+            if dev["skin_limit"].default:
+                default_tdp = dev["skin_limit"].default
+            if dev["skin_limit"].smax:
+                max_tdp = dev["skin_limit"].smax
+        except Exception as e:
+            logger.error(f"Failed to get TDP limits for {prod}:\n{e}")
+
         pp_enable |= bool(os.environ.get("HHD_ADJ_DEBUG"))
         drivers.append(
             SmuDriverPlugin(

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

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