zenmaster 1.2.0__tar.gz → 1.2.2__tar.gz

{zenmaster-1.2.0/zenmaster.egg-info → zenmaster-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zenmaster
-Version: 1.2.0
+Version: 1.2.2
 Summary: Adjust power management settings for Ryzen CPUs on Linux, Windows, and macOS
 Author-email: oxGorou <lekhanhbinh2901@gmail.com>
 License-Expression: GPL-3.0-only
@@ -193,7 +193,7 @@ print(f"SMN 0x0005A380 = 0x{value:08X}")
 
 ## Technical Comparison: ZenMaster vs. RyzenAdj
 
-| Feature | RyzenAdj | ZenMaster v1.2.0 |
+| Feature | RyzenAdj | ZenMaster v1.2.2 |
 |---|---|---|
 | **Installation** | Compilation from source (`cmake`, `make`, `libpci-dev`) | `pip install zenmaster` (pure Python package) |
 | **Supported Families** | ~15 APU and desktop families | 44 families (Zen 1 to Zen 5/6, Desktop, Mobile, Threadripper, Server EPYC via HSMP) |

{zenmaster-1.2.0 → zenmaster-1.2.2}/README.md

@@ -162,7 +162,7 @@ print(f"SMN 0x0005A380 = 0x{value:08X}")
 
 ## Technical Comparison: ZenMaster vs. RyzenAdj
 
-| Feature | RyzenAdj | ZenMaster v1.2.0 |
+| Feature | RyzenAdj | ZenMaster v1.2.2 |
 |---|---|---|
 | **Installation** | Compilation from source (`cmake`, `make`, `libpci-dev`) | `pip install zenmaster` (pure Python package) |
 | **Supported Families** | ~15 APU and desktop families | 44 families (Zen 1 to Zen 5/6, Desktop, Mobile, Threadripper, Server EPYC via HSMP) |

{zenmaster-1.2.0 → zenmaster-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zenmaster"
-version = "1.2.0"
+version = "1.2.2"
 requires-python = ">=3.10"
 description = "Adjust power management settings for Ryzen CPUs on Linux, Windows, and macOS"
 readme = "README.md"

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/__init__.py

@@ -26,7 +26,7 @@ from zenmaster.errors import (
 try:
     __version__ = version("zenmaster")
 except PackageNotFoundError:
-    __version__ = "1.2.0"
+    __version__ = "1.2.2"
 
 __all__ = [
     "CpuInfo", "detect", "resolve", "apply", "ApplyResult", "runner", "smu", "sensors", "table",

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/cli.py

@@ -490,9 +490,17 @@ _SENSOR_ROWS = [
 
 
 def _show_sensors(json_out: bool, family: str = "") -> None:
+    if not smu.pm_table_supported(family):
+        msg = _pm_unavailable_msg(family)
+        if json_out:
+            print(json.dumps({"error": msg}))
+        else:
+            print(f"ZenMaster: {msg}", file=sys.stderr)
+        sys.exit(1)
+
     sensors = smu.read_pm_sensors(family)
     if sensors is None:
-        msg = _pm_unavailable_msg(family)
+        msg = "Failed to read PM table"
         if json_out:
             print(json.dumps({"error": msg}))
         else:

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/hardware.py

@@ -97,7 +97,16 @@ def _libSystem() -> ctypes.CDLL | None:
     global _libc
     if _libc is None:
         try:
-            _libc = ctypes.CDLL("/usr/lib/libSystem.B.dylib")
+            libc = ctypes.CDLL("/usr/lib/libSystem.B.dylib")
+            libc.sysctlbyname.restype = ctypes.c_int
+            libc.sysctlbyname.argtypes = [
+                ctypes.c_char_p,
+                ctypes.c_void_p,
+                ctypes.POINTER(ctypes.c_size_t),
+                ctypes.c_void_p,
+                ctypes.c_size_t,
+            ]
+            _libc = libc
         except (OSError, Exception):
             return None
     return _libc
@@ -128,6 +137,8 @@ def _sysctl_int(name: str) -> int:
         size = ctypes.c_size_t(ctypes.sizeof(val))
         if libc.sysctlbyname(name.encode(), ctypes.byref(val), ctypes.byref(size), None, 0) != 0:
             return 0
+        if size.value == 4:
+            return int(ctypes.c_int32(val.value & 0xFFFFFFFF).value)
         return int(val.value)
     except (OSError, Exception):
         return 0

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/linux.py

@@ -11,7 +11,10 @@ from typing import Any
 
 from zenmaster.errors import BackendUnavailable, SMUNotInitialized
 from zenmaster.pmtable import PM_TABLE_CMDS, TABLE_SIZES, DEFAULT_TABLE_SIZE
-from zenmaster.mailbox import MP1, MP1_DEFAULT, RSMU, RSMU_DEFAULT, HSMP, HSMP_DEFAULT, NARGS
+from zenmaster.mailbox import (
+    MP1, MP1_DEFAULT, RSMU, RSMU_DEFAULT, HSMP, HSMP_DEFAULT, NARGS,
+    DEFAULT_TIMEOUT, poll_response, transfer_with_retry,
+)
 from zenmaster.smu import SMU_OK, SMU_FAILED, SMU_REJECTED_PREREQ, ModuleStatus
 
 DRIVER_NAME  = "ryzen_smu"
@@ -27,7 +30,7 @@ _PCI_MUTEX_FALLBACK: str = "/tmp/access_pci.lock"
 _PCI_MUTEX_TIMEOUT_MS: int = 5000
 
 
-def acquire_pci_mutex(timeout_ms: int = _PCI_MUTEX_TIMEOUT_MS) -> int | None:
+def acquire_pci_mutex(timeout_ms: int = _PCI_MUTEX_TIMEOUT_MS) -> Any:
     path = PCI_MUTEX_NAME
     fd = None
     try:
@@ -87,10 +90,11 @@ MIN_VERSION = (0, 1, 7)
 
 _POLL_N   = 100
 _SLEEP_S  = 0.0001
-_DEADLINE = 1.0
+_DEADLINE = DEFAULT_TIMEOUT
 _lock     = threading.Lock()
 _backend: str | None = None
 _fd: int | None = None
+_cached_pm_ver: int | None = None
 
 
 def version_str(v: tuple[int, ...]) -> str:
@@ -159,7 +163,7 @@ def secure_boot_enabled() -> bool:
     try:
         out = subprocess.run(
             ["mokutil", "--sb-state"],
-            capture_output=True, text=True, timeout=3,
+            capture_output=True, text=True, timeout=5,
         ).stdout.lower()
         return "enabled" in out
     except Exception:
@@ -185,6 +189,17 @@ def _pci_writable() -> bool:
         return False
 
 
+def _ryzen_smu_writable() -> bool:
+    if not (os.path.isdir(DRIVER_PATH) and module_version_ok() and os.path.exists(SMN_PATH)):
+        return False
+    try:
+        fd = os.open(SMN_PATH, os.O_RDWR)
+        os.close(fd)
+        return True
+    except OSError:
+        return False
+
+
 def init() -> str:
     global _backend
 
@@ -215,6 +230,10 @@ def init() -> str:
         _backend = "pci"
         return _backend
 
+    if _ryzen_smu_writable():
+        _backend = "ryzen_smu"
+        return _backend
+
     if os.path.exists(PCI_CONFIG):
         raise BackendUnavailable(
             "Secure Boot is off, so ZenMaster uses PCI direct access, but the PCI "
@@ -256,7 +275,7 @@ def _pci_read(fd: int, addr: int) -> int:
 
 def _pci_write(fd: int, addr: int, value: int) -> None:
     os.lseek(fd, NB_ADDR, os.SEEK_SET)
-    os.write(fd, struct.pack("<I", addr))
+    os.write(fd, struct.pack("<I", addr & ~3))
     os.lseek(fd, NB_DATA, os.SEEK_SET)
     os.write(fd, struct.pack("<I", value))
 
@@ -267,17 +286,7 @@ def _send_seq(write: Any, read: Any, fd: int, msg: int, rsp: int, args: int, op:
     for i in range(1, NARGS):
         write(fd, args + i * 4, 0)
     write(fd, msg, op)
-    for _ in range(_POLL_N):
-        r = read(fd, rsp)
-        if r:
-            return r
-    deadline = time.monotonic() + _DEADLINE
-    while time.monotonic() < deadline:
-        time.sleep(_SLEEP_S)
-        r = read(fd, rsp)
-        if r:
-            return r
-    return SMU_FAILED
+    return poll_response(lambda a: read(fd, a), rsp, _POLL_N, _SLEEP_S, _DEADLINE) or SMU_FAILED
 
 
 def _require_init() -> None:
@@ -378,6 +387,8 @@ def smu_command(msg_id: int, arg: int = 0) -> int:
 
 
 def pm_table_supported(family: str = "") -> bool:
+    if _cached_pm_ver:
+        return True
     if os.path.exists(DRIVER_PATH + "/pm_table"):
         return True
     return family in PM_TABLE_CMDS
@@ -406,6 +417,9 @@ def _read_devmem(phys: int, size: int) -> bytes | None:
 
 
 def _read_pm_table_pci(family: str) -> tuple[bytes, int] | None:
+    global _cached_pm_ver
+    if _backend is None:
+        return None
     cmds = PM_TABLE_CMDS.get(family)
     if cmds is None:
         return None
@@ -414,7 +428,8 @@ def _read_pm_table_pci(family: str) -> tuple[bytes, int] | None:
     status, out = query_rsmu(family, ver_op, 0)
     if status != SMU_OK or not out[0]:
         return None
-    ver = out[0]
+    ver = out[0] & 0xFFFFFFFF
+    _cached_pm_ver = ver
     size = TABLE_SIZES.get(ver, DEFAULT_TABLE_SIZE)
 
     status, out = query_rsmu(family, addr_op, extra)
@@ -424,10 +439,7 @@ def _read_pm_table_pci(family: str) -> tuple[bytes, int] | None:
     if not phys:
         return None
 
-    status, _ = query_rsmu(family, transfer_op, extra)
-    if status == SMU_REJECTED_PREREQ:
-        time.sleep(0.01)
-        status, _ = query_rsmu(family, transfer_op, extra)
+    status = transfer_with_retry(lambda: query_rsmu(family, transfer_op, extra)[0], (0.1, 0.5))
     if status != SMU_OK:
         return None
 
@@ -435,6 +447,19 @@ def _read_pm_table_pci(family: str) -> tuple[bytes, int] | None:
     return (data, ver) if data is not None else None
 
 
+def get_smu_version(family: str = "") -> int:
+    if _backend in ("ryzen_smu", None):
+        try:
+            with open(DRIVER_PATH + "/version", "r") as f:
+                return int(f.read().strip(), 16) & 0xFFFFFFFF
+        except (OSError, ValueError):
+            pass
+    if _backend is None:
+        return 0
+    status, out = query_mp1(family, 0x02, 1)
+    return (out[0] & 0xFFFFFFFF) if status == SMU_OK and out[0] else 0
+
+
 def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
     if _backend == "pci":
         return _read_pm_table_pci(family)
@@ -445,16 +470,45 @@ def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
 
 
 def read_pm_table_version(family: str = "") -> int:
+    global _cached_pm_ver
+    if _cached_pm_ver:
+        return _cached_pm_ver
+
     if _backend == "pci":
+        if family in PM_TABLE_CMDS:
+            ver_op = PM_TABLE_CMDS[family][0]
+            status, out = query_rsmu(family, ver_op, 0)
+            if status == SMU_OK and out[0]:
+                _cached_pm_ver = out[0] & 0xFFFFFFFF
+                return _cached_pm_ver
         r = _read_pm_table_pci(family)
-        return r[1] if r else 0
+        if r:
+            _cached_pm_ver = r[1] & 0xFFFFFFFF
+            return _cached_pm_ver
+        return 0
+
     try:
         with open(DRIVER_PATH + "/pm_table_version", "rb") as f:
             raw = f.read(4)
-        return struct.unpack("<I", raw)[0] if len(raw) >= 4 else 0
+        ver = struct.unpack("<I", raw)[0] & 0xFFFFFFFF if len(raw) >= 4 else 0
+        if ver:
+            _cached_pm_ver = ver
+            return _cached_pm_ver
     except OSError:
-        r = _read_pm_table_pci(family)
-        return r[1] if r else 0
+        pass
+
+    if _backend is not None and family in PM_TABLE_CMDS:
+        ver_op = PM_TABLE_CMDS[family][0]
+        status, out = query_rsmu(family, ver_op, 0)
+        if status == SMU_OK and out[0]:
+            _cached_pm_ver = out[0] & 0xFFFFFFFF
+            return _cached_pm_ver
+
+    r = _read_pm_table_pci(family)
+    if r:
+        _cached_pm_ver = r[1] & 0xFFFFFFFF
+        return _cached_pm_ver
+    return 0
 
 
 def read_pm_table(family: str = "") -> bytes | None:
@@ -477,7 +531,7 @@ def read_pm_table(family: str = "") -> bytes | None:
 
 
 def close() -> None:
-    global _backend, _fd
+    global _backend, _fd, _cached_pm_ver
     if _fd is not None:
         try:
             os.close(_fd)
@@ -485,3 +539,4 @@ def close() -> None:
             pass
         _fd = None
     _backend = None
+    _cached_pm_ver = None

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/macos.py

@@ -1,5 +1,10 @@
 from __future__ import annotations
+from contextlib import contextmanager
+import fcntl
+import os
 import threading
+import time
+from typing import Any
 
 from zenmaster import directhw, iopci
 from zenmaster.hardware import _sysctl_str
@@ -7,29 +12,84 @@ from zenmaster.errors import BackendUnavailable, SMUNotInitialized
 from zenmaster.pmtable import PM_TABLE_CMDS, TABLE_SIZES, DEFAULT_TABLE_SIZE
 from zenmaster.mailbox import (
     MP1, MP1_DEFAULT, RSMU, RSMU_DEFAULT, HSMP, HSMP_DEFAULT,
-    mailbox_send, mailbox_query, transfer_with_retry,
+    DEFAULT_TIMEOUT, mailbox_send, mailbox_query, transfer_with_retry,
 )
 from zenmaster.smu import SMU_OK, ModuleStatus
 
 DRIVER_NAME = "DirectHW"
+PCI_MUTEX_NAME: str = "/tmp/access_pci.lock"
+_PCI_MUTEX_TIMEOUT_MS: int = 5000
 
 NB_ADDR  = 0xB8
 NB_DATA  = 0xBC
 PCI_ADDR = 0xCF8
 PCI_DATA = 0xCFC
 
-_POLL_N     = 100
 _FAST_POLL  = 64
 _POLL_SLEEP = 0.0005
+_TIMEOUT    = DEFAULT_TIMEOUT
 _lock       = threading.Lock()
 _backend: str | None = None
 _force: str | None = None
+_cached_pm_ver: int | None = None
 
 _KEXT_URL = "https://github.com/joevt/directhw"
 
 _IOPCI_DEBUG_MSG = "The IOPCIBridge path requires the debug=0x144 boot-arg."
 
 
+def acquire_pci_mutex(timeout_ms: int = _PCI_MUTEX_TIMEOUT_MS) -> Any:
+    path = PCI_MUTEX_NAME
+    try:
+        fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o666)
+    except OSError:
+        return None
+    deadline = time.monotonic() + (timeout_ms / 1000.0)
+    while True:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return fd
+        except (BlockingIOError, OSError):
+            if time.monotonic() >= deadline:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+                return None
+            time.sleep(0.005)
+
+
+def release_pci_mutex(handle: Any) -> bool:
+    if handle is None:
+        return False
+    try:
+        fcntl.flock(handle, fcntl.LOCK_UN)
+        return True
+    except OSError:
+        return False
+
+
+def close_pci_mutex(handle: Any) -> bool:
+    if handle is None:
+        return False
+    try:
+        os.close(handle)
+        return True
+    except OSError:
+        return False
+
+
+@contextmanager
+def pci_mutex_guard(timeout_ms: int = _PCI_MUTEX_TIMEOUT_MS) -> Any:
+    h = acquire_pci_mutex(timeout_ms)
+    try:
+        yield h
+    finally:
+        if h is not None:
+            release_pci_mutex(h)
+            close_pci_mutex(h)
+
+
 def force_iopci() -> None:
     global _force
     _force = "iopci"
@@ -52,13 +112,17 @@ def module_version_ok() -> bool:
 
 
 def module_status() -> ModuleStatus:
-    if not is_available():
+    if _backend == "iopci":
+        return ModuleStatus(True, "loaded", "", None)
+    if not directhw.is_loaded():
+        if _debug_boot_arg_ok() and iopci.is_available():
+            return ModuleStatus(True, "loaded", "", None)
         return ModuleStatus(False, "unknown", "", "not_loaded")
     return ModuleStatus(True, "loaded", "", None)
 
 
 def is_available() -> bool:
-    return directhw.is_loaded() or iopci.is_available()
+    return directhw.is_loaded() or (_debug_boot_arg_ok() and iopci.is_available())
 
 
 def init() -> str:
@@ -140,12 +204,12 @@ def _smn_write(addr: int, value: int) -> None:
 
 def _mailbox_send(msg: int, rsp: int, args_addr: int, op: int, arg0: int) -> int:
     return mailbox_send(_smn_write, _smn_read, msg, rsp, args_addr, op, arg0,
-                         _POLL_N, _FAST_POLL, _POLL_SLEEP)
+                        _FAST_POLL, _POLL_SLEEP, _TIMEOUT)
 
 
 def _mailbox_query(msg: int, rsp: int, args_base: int, op: int, arg0: int = 0) -> tuple[int, list[int]]:
     return mailbox_query(_smn_write, _smn_read, msg, rsp, args_base, op, arg0,
-                          _POLL_N, _FAST_POLL, _POLL_SLEEP)
+                         _FAST_POLL, _POLL_SLEEP, _TIMEOUT)
 
 
 def _require_init() -> None:
@@ -157,14 +221,16 @@ def _send(table: dict, default: tuple, family: str, op: int, arg0: int) -> int:
     _require_init()
     msg, rsp, args = table.get(family, default)
     with _lock:
-        return _mailbox_send(msg, rsp, args, op, arg0)
+        with pci_mutex_guard():
+            return _mailbox_send(msg, rsp, args, op, arg0)
 
 
 def _query(table: dict, default: tuple, family: str, op: int, arg0: int) -> tuple[int, list[int]]:
     _require_init()
     msg, rsp, args = table.get(family, default)
     with _lock:
-        return _mailbox_query(msg, rsp, args, op, arg0)
+        with pci_mutex_guard():
+            return _mailbox_query(msg, rsp, args, op, arg0)
 
 
 def send_mp1(family: str, op: int, arg0: int = 0) -> int:
@@ -194,49 +260,66 @@ def query_hsmp(family: str, op: int, arg0: int = 0) -> tuple[int, list[int]]:
 def read_smn(addr: int) -> int:
     _require_init()
     with _lock:
-        return _smn_read(addr)
+        with pci_mutex_guard():
+            return _smn_read(addr)
 
 
 def write_smn(addr: int, value: int) -> None:
     _require_init()
     with _lock:
-        _smn_write(addr, value)
+        with pci_mutex_guard():
+            _smn_write(addr, value)
 
 
 def smu_command(msg_id: int, arg: int = 0) -> int:
     _require_init()
     msg, rsp, args = MP1_DEFAULT
     with _lock:
-        return _mailbox_send(msg, rsp, args, msg_id, arg)
+        with pci_mutex_guard():
+            return _mailbox_send(msg, rsp, args, msg_id, arg)
+
+
+def get_smu_version(family: str = "") -> int:
+    if _backend is None:
+        return 0
+    status, out = query_mp1(family, 0x02, 1)
+    return (out[0] & 0xFFFFFFFF) if status == SMU_OK and out[0] else 0
 
 
 def pm_table_supported(family: str = "") -> bool:
+    if _cached_pm_ver:
+        return True
     return _backend != "iopci" and family in PM_TABLE_CMDS
 
 
 def _transfer_with_retry(msg: int, rsp: int, args_base: int, op: int, arg0: int = 0,
-                         delays: tuple[float, ...] = (0.01, 0.1)) -> int:
+                         delays: tuple[float, ...] = (0.1, 0.5)) -> int:
     def once() -> int:
         with _lock:
-            return _mailbox_send(msg, rsp, args_base, op, arg0)
+            with pci_mutex_guard():
+                return _mailbox_send(msg, rsp, args_base, op, arg0)
     return transfer_with_retry(once, delays)
 
 
 def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
+    global _cached_pm_ver
     if _backend in (None, "iopci") or family not in PM_TABLE_CMDS:
         return None
     ver_op, addr_op, transfer_op, addr_64bit, extra = PM_TABLE_CMDS[family]
     msg, rsp, args_base = RSMU.get(family, RSMU_DEFAULT)
 
     with _lock:
-        status, out = _mailbox_query(msg, rsp, args_base, ver_op)
+        with pci_mutex_guard():
+            status, out = _mailbox_query(msg, rsp, args_base, ver_op)
     if status != SMU_OK or not out[0]:
         return None
-    ver = out[0]
+    ver = out[0] & 0xFFFFFFFF
+    _cached_pm_ver = ver
     size = TABLE_SIZES.get(ver, DEFAULT_TABLE_SIZE)
 
     with _lock:
-        status, out = _mailbox_query(msg, rsp, args_base, addr_op, extra)
+        with pci_mutex_guard():
+            status, out = _mailbox_query(msg, rsp, args_base, addr_op, extra)
     if status != SMU_OK:
         return None
     phys_addr = (out[1] << 32) | out[0] if addr_64bit else out[0]
@@ -251,8 +334,26 @@ def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
 
 
 def read_pm_table_version(family: str = "") -> int:
+    global _cached_pm_ver
+    if _backend in (None, "iopci"):
+        return 0
+    if _cached_pm_ver:
+        return _cached_pm_ver
+
+    if family in PM_TABLE_CMDS:
+        ver_op = PM_TABLE_CMDS[family][0]
+        msg, rsp, args_base = RSMU.get(family, RSMU_DEFAULT)
+        with _lock:
+            with pci_mutex_guard():
+                status, out = _mailbox_query(msg, rsp, args_base, ver_op)
+        if status == SMU_OK and out[0]:
+            _cached_pm_ver = out[0] & 0xFFFFFFFF
+            return _cached_pm_ver
     r = read_pm_table_full(family)
-    return r[1] if r else 0
+    if r:
+        _cached_pm_ver = r[1] & 0xFFFFFFFF
+        return _cached_pm_ver
+    return 0
 
 
 def read_pm_table(family: str = "") -> bytes | None:
@@ -261,7 +362,9 @@ def read_pm_table(family: str = "") -> bytes | None:
 
 
 def close() -> None:
-    global _backend
+    global _backend, _cached_pm_ver, DRIVER_NAME
     directhw.close()
     iopci.close()
+    DRIVER_NAME = "DirectHW"
     _backend = None
+    _cached_pm_ver = None

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/mailbox.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 import time
+from typing import Any
 
 from zenmaster.smu import SMU_FAILED, SMU_REJECTED_PREREQ
 
 NARGS = 6
+DEFAULT_TIMEOUT: float = 5.0
 
 MP1: dict[str, tuple[int, int, int]] = {
     "SummitRidge":   (0x3B10528, 0x3B10564, 0x3B10598),
@@ -49,41 +51,48 @@ HSMP: dict[str, tuple[int, int, int]] = {
 HSMP_DEFAULT = (0x3B10A8C, 0x3B10A90, 0x3B10A94)
 
 
-def poll_response(smn_read, rsp: int, poll_n: int, fast_poll: int, poll_sleep: float) -> int:
-    for i in range(poll_n):
+def poll_response(smn_read: Any, rsp: int, fast_poll: int = 64, poll_sleep: float = 0.0005,
+                  timeout: float = DEFAULT_TIMEOUT) -> int:
+    for _ in range(fast_poll):
+        r = smn_read(rsp)
+        if r:
+            return r
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        time.sleep(poll_sleep)
         r = smn_read(rsp)
         if r:
             return r
-        if i >= fast_poll:
-            time.sleep(poll_sleep)
     return 0
 
 
-def mailbox_send(smn_write, smn_read, msg: int, rsp: int, args_addr: int, op: int, arg0: int,
-                  poll_n: int, fast_poll: int, poll_sleep: float) -> int:
+def mailbox_send(smn_write: Any, smn_read: Any, msg: int, rsp: int, args_addr: int, op: int, arg0: int,
+                 fast_poll: int = 64, poll_sleep: float = 0.0005,
+                 timeout: float = DEFAULT_TIMEOUT) -> int:
     smn_write(rsp, 0)
     smn_write(args_addr, arg0)
     for i in range(1, NARGS):
         smn_write(args_addr + i * 4, 0)
     smn_write(msg, op)
-    return poll_response(smn_read, rsp, poll_n, fast_poll, poll_sleep) or SMU_FAILED
+    return poll_response(smn_read, rsp, fast_poll, poll_sleep, timeout) or SMU_FAILED
 
 
-def mailbox_query(smn_write, smn_read, msg: int, rsp: int, args_base: int, op: int, arg0: int,
-                   poll_n: int, fast_poll: int, poll_sleep: float) -> tuple[int, list[int]]:
+def mailbox_query(smn_write: Any, smn_read: Any, msg: int, rsp: int, args_base: int, op: int, arg0: int,
+                  fast_poll: int = 64, poll_sleep: float = 0.0005,
+                  timeout: float = DEFAULT_TIMEOUT) -> tuple[int, list[int]]:
     smn_write(rsp, 0)
     for i in range(NARGS):
         smn_write(args_base + i * 4, 0)
     if arg0:
         smn_write(args_base, arg0)
     smn_write(msg, op)
-    r = poll_response(smn_read, rsp, poll_n, fast_poll, poll_sleep)
+    r = poll_response(smn_read, rsp, fast_poll, poll_sleep, timeout)
     if r:
         return r, [smn_read(args_base + i * 4) for i in range(NARGS)]
     return SMU_FAILED, [0] * NARGS
 
 
-def transfer_with_retry(send_once, delays: tuple[float, ...] = (0.01, 0.1)) -> int:
+def transfer_with_retry(send_once, delays: tuple[float, ...] = (0.1, 0.5)) -> int:
     status = send_once()
     for delay in delays:
         if status != SMU_REJECTED_PREREQ:

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/smu.py

@@ -58,10 +58,8 @@ def _backend() -> Any:
 
 def smu_command(msg_id: int, arg: int = 0) -> int:
     b = _backend() if callable(_backend) else _backend
-    fn = getattr(b, "smu_command", None)
-    if fn is not None:
-        return fn(msg_id, arg)
-    ensure_backend()
+    if getattr(b, "active_backend", None) is not None and not ensure_backend():
+        return SMU_FAILED
     b = _backend() if callable(_backend) else _backend
     fn = getattr(b, "smu_command", None)
     if fn is not None:
@@ -116,18 +114,21 @@ def pm_table_supported(family: str = "") -> bool:
 
 
 def read_pm_table(family: str = "") -> bytes | None:
+    ensure_backend()
     b = _backend()
     fn = getattr(b, "read_pm_table", None)
     return fn(family) if fn else None
 
 
 def read_pm_table_version(family: str = "") -> int:
+    ensure_backend()
     b = _backend()
     fn = getattr(b, "read_pm_table_version", None)
     return fn(family) if fn else 0
 
 
 def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
+    ensure_backend()
     b = _backend()
     fn = getattr(b, "read_pm_table_full", None)
     if fn:
@@ -191,7 +192,9 @@ def send_arg(family: str, name: str, value: int) -> list[tuple[str, int, int]]:
     from zenmaster.errors import UnsupportedCPU
     if not runner.is_supported(family):
         raise UnsupportedCPU(f"'{family}' is not a supported CPU family")
-    ensure_backend()
+    b = _backend() if callable(_backend) else _backend
+    if getattr(b, "active_backend", None) is not None and active_backend() is None:
+        init()
     out: list[tuple[str, int, int]] = []
     use_hsmp = runner.is_hsmp(family)
     for is_mp1, op in runner.lookup(family, name):
@@ -225,16 +228,26 @@ def unavailable_reason() -> str | None:
 
 
 def get_bios_if_ver(family: str) -> int:
-    ensure_backend()
+    if not ensure_backend():
+        return 0
     status, out = query_mp1(family, 0x03, 0)
     return out[0] if status == SMU_OK else 0
 
 
 def get_smu_version(family: str) -> int:
-    ensure_backend()
-    status, out = query_mp1(family, 0x02, 1)
-    if status == SMU_OK and out[0]:
-        return out[0]
+    if ensure_backend():
+        b = _backend()
+        fn = getattr(b, "get_smu_version", None)
+        if fn is not None:
+            try:
+                ver = fn(family)
+                if ver:
+                    return ver
+            except Exception:
+                pass
+        status, out = query_mp1(family, 0x02, 1)
+        if status == SMU_OK and out[0]:
+            return out[0]
     if platform.system() == "Linux":
         for path in ("/sys/kernel/ryzen_smu_drv/version", "/sys/kernel/ryzen_smu_drv/drv_version"):
             try:

{zenmaster-1.2.0 → zenmaster-1.2.2}/zenmaster/windows.py

@@ -11,7 +11,7 @@ from zenmaster.errors import BackendUnavailable, SMUNotInitialized
 from zenmaster.pmtable import PM_TABLE_CMDS, TABLE_SIZES, DEFAULT_TABLE_SIZE
 from zenmaster.mailbox import (
     MP1, MP1_DEFAULT, RSMU, RSMU_DEFAULT, HSMP, HSMP_DEFAULT,
-    mailbox_send, mailbox_query, transfer_with_retry,
+    DEFAULT_TIMEOUT, mailbox_send, mailbox_query, transfer_with_retry,
 )
 from zenmaster.smu import SMU_OK, ModuleStatus
 
@@ -24,9 +24,9 @@ _DEVICE_PATHS = [
 ]
 _IOCTL_LOAD  = 0xA1B22084
 _IOCTL_EXEC  = 0xA1B22104
-_POLL_N      = 8192
 _FAST_POLL   = 64
 _POLL_SLEEP  = 0.0005
+_TIMEOUT     = DEFAULT_TIMEOUT
 _lock        = threading.Lock()
 _handle      = None
 _k32         = None
@@ -56,6 +56,8 @@ def _query_pawnio_info() -> str | None:
             return winreg.QueryValueEx(key, "DisplayVersion")[0]
         except OSError:
             return ""
+        finally:
+            winreg.CloseKey(key)
     except OSError:
         return None
 
@@ -81,7 +83,7 @@ def module_status() -> ModuleStatus:
 
 
 def is_available() -> bool:
-    return _pawnio_info() is not None
+    return _handle is not None or _pawnio_info() is not None
 
 
 def acquire_pci_mutex(timeout_ms: int = _PCI_MUTEX_TIMEOUT_MS) -> Any:
@@ -186,16 +188,18 @@ def init() -> str:
         raise BackendUnavailable(f"PawnIO module not found: {module_path}")
 
     ver = _pawnio_info()
-    if ver is None:
-        raise BackendUnavailable(
-            "PawnIO driver is not installed.\n"
-            f"Download and run the installer: {_PAWNIO_INSTALLER_URL}\n"
-            "After installation, reboot and try again."
-        )
-
-    k32    = _make_k32()
+    try:
+        k32 = _make_k32()
+    except AttributeError as e:
+        raise BackendUnavailable("PawnIO driver is only supported on Windows.") from e
     handle = _open_device(k32)
     if handle is None:
+        if ver is None:
+            raise BackendUnavailable(
+                "PawnIO driver is not installed.\n"
+                f"Download and run the installer: {_PAWNIO_INSTALLER_URL}\n"
+                "After installation, reboot and try again."
+            )
         raise BackendUnavailable(
             "PawnIO device not found. The driver may need a reboot to activate.\n"
             f"If not installed: {_PAWNIO_INSTALLER_URL}"
@@ -240,6 +244,10 @@ def _require_init() -> None:
         raise SMUNotInitialized("PawnIO not initialized, call smu.init() first")
 
 
+_cached_pm_ver: int | None = None
+_cached_pm_size: int | None = None
+
+
 def _execute(fn_name: str, in_args: list[int], out_count: int) -> list[int]:
     fn_bytes = fn_name.encode("ascii")[:31]
     name_buf = struct.pack("32s", fn_bytes)
@@ -265,6 +273,27 @@ def _execute(fn_name: str, in_args: list[int], out_count: int) -> list[int]:
     return list(struct.unpack(f"<{count}q", out_buf.raw[: count * 8]))
 
 
+def _execute_cmd(fn_name: str, in_args: list[int] | None = None) -> bool:
+    if in_args is None:
+        in_args = []
+    fn_bytes = fn_name.encode("ascii")[:31]
+    name_buf = struct.pack("32s", fn_bytes)
+    args_buf = struct.pack(f"<{len(in_args)}q", *in_args) if in_args else b""
+    payload  = name_buf + args_buf
+    in_buf   = ctypes.create_string_buffer(payload)
+    ret      = ctypes.wintypes.DWORD(0)
+
+    ok = _k32.DeviceIoControl(
+        ctypes.wintypes.HANDLE(_handle),
+        ctypes.wintypes.DWORD(_IOCTL_EXEC),
+        ctypes.cast(in_buf, ctypes.c_void_p),
+        ctypes.wintypes.DWORD(len(payload)),
+        None, 0,
+        ctypes.byref(ret), None,
+    )
+    return bool(ok)
+
+
 def _smn_read(addr: int) -> int:
     result = _execute("ioctl_read_smu_register", [addr], 1)
     return result[0] & 0xFFFFFFFF if result else 0
@@ -276,24 +305,61 @@ def _smn_write(addr: int, value: int) -> None:
 
 def _mailbox_send(msg: int, rsp: int, args_addr: int, op: int, arg0: int) -> int:
     return mailbox_send(_smn_write, _smn_read, msg, rsp, args_addr, op, arg0,
-                         _POLL_N, _FAST_POLL, _POLL_SLEEP)
+                        _FAST_POLL, _POLL_SLEEP, _TIMEOUT)
 
 
 def _mailbox_query(msg: int, rsp: int, args_base: int, op: int, arg0: int = 0) -> tuple[int, list[int]]:
     return mailbox_query(_smn_write, _smn_read, msg, rsp, args_base, op, arg0,
-                          _POLL_N, _FAST_POLL, _POLL_SLEEP)
+                         _FAST_POLL, _POLL_SLEEP, _TIMEOUT)
+
+
+def _resolve_pm_table() -> tuple[int, int] | None:
+    _require_init()
+    import time
+    for delay in (0.0, 0.1, 0.5):
+        if delay:
+            time.sleep(delay)
+        with _lock:
+            with pci_mutex_guard():
+                out = _execute("ioctl_resolve_pm_table", [], 2)
+        if len(out) == 2 and out[0] != 0:
+            return (out[0] & 0xFFFFFFFF), out[1]
+    return None
+
+
+def _update_pm_table(family: str = "") -> bool:
+    _require_init()
+    import time
+    for delay in (0.0, 0.1, 0.5):
+        if delay:
+            time.sleep(delay)
+        with _lock:
+            with pci_mutex_guard():
+                ok = _execute_cmd("ioctl_update_pm_table")
+        if ok:
+            return True
+    if family in PM_TABLE_CMDS:
+        _ver_op, _addr_op, transfer_op, _addr_64bit, extra = PM_TABLE_CMDS[family]
+        msg, rsp, args_base = RSMU.get(family, RSMU_DEFAULT)
+        status = _transfer_with_retry(msg, rsp, args_base, transfer_op, extra)
+        return status == SMU_OK
+    return False
 
 
 def _read_physical_memory(phys_addr: int, size: int) -> bytes | None:
-    n   = (size + 7) // 8
-    raw = _execute("ioctl_read_pm_table", [phys_addr, n], n)
-    if len(raw) == n:
-        return struct.pack(f"<{n}q", *raw)[:size]
+    n = min((size + 7) // 8, 512)
+    with _lock:
+        raw = _execute("ioctl_read_pm_table", [], n)
+    if raw:
+        data = struct.pack(f"<{len(raw)}q", *raw)[:size]
+        if len(data) < size:
+            data = data + b"\x00" * (size - len(data))
+        return data
     return None
 
 
 def _transfer_with_retry(msg: int, rsp: int, args_base: int, op: int, arg0: int = 0,
-                         delays: tuple[float, ...] = (0.01, 0.1)) -> int:
+                         delays: tuple[float, ...] = (0.1, 0.5)) -> int:
     def once() -> int:
         with _lock:
             with pci_mutex_guard():
@@ -363,43 +429,105 @@ def smu_command(msg_id: int, arg: int = 0) -> int:
             return _mailbox_send(msg, rsp, args, msg_id, arg)
 
 
+def get_smu_version(family: str = "") -> int:
+    if _handle is None or _k32 is None:
+        return 0
+    with _lock:
+        with pci_mutex_guard():
+            out = _execute("ioctl_get_smu_version", [], 1)
+    if out and out[0]:
+        return out[0] & 0xFFFFFFFF
+    msg, rsp, args = MP1.get(family, MP1_DEFAULT)
+    with _lock:
+        with pci_mutex_guard():
+            status, res = _mailbox_query(msg, rsp, args, 0x02, 1)
+    return (res[0] & 0xFFFFFFFF) if status == SMU_OK and res[0] else 0
+
+
 def pm_table_supported(family: str = "") -> bool:
+    if _cached_pm_ver:
+        return True
     return family in PM_TABLE_CMDS
 
 
-def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
-    if not _handle or family not in PM_TABLE_CMDS:
-        return None
-    ver_op, addr_op, transfer_op, addr_64bit, extra = PM_TABLE_CMDS[family]
-    msg, rsp, args_base = RSMU.get(family, RSMU_DEFAULT)
+def _cache_pm_ver(ver: int) -> int:
+    global _cached_pm_ver, _cached_pm_size
+    _cached_pm_ver = ver & 0xFFFFFFFF
+    _cached_pm_size = TABLE_SIZES.get(_cached_pm_ver, DEFAULT_TABLE_SIZE)
+    return _cached_pm_ver
 
+
+def _read_pm_ver_rsmu(family: str = "") -> int:
+    if _handle is None or _k32 is None or family not in PM_TABLE_CMDS:
+        return 0
+    ver_op = PM_TABLE_CMDS[family][0]
+    msg, rsp, args_base = RSMU.get(family, RSMU_DEFAULT)
     with _lock:
         with pci_mutex_guard():
             status, out = _mailbox_query(msg, rsp, args_base, ver_op)
-    if status != SMU_OK or not out[0]:
-        return None
-    ver = out[0]
-    size = TABLE_SIZES.get(ver, DEFAULT_TABLE_SIZE)
+    return (out[0] & 0xFFFFFFFF) if status == SMU_OK and out[0] else 0
 
-    with _lock:
-        with pci_mutex_guard():
-            status, out = _mailbox_query(msg, rsp, args_base, addr_op, extra)
-    if status != SMU_OK:
+
+def read_pm_table_full(family: str = "") -> tuple[bytes, int] | None:
+    if _handle is None or _k32 is None:
         return None
-    phys_addr = (out[1] << 32) | out[0] if addr_64bit else out[0]
-    if not phys_addr:
+
+    global _cached_pm_ver, _cached_pm_size
+
+    if _cached_pm_ver is None:
+        resolved = _resolve_pm_table()
+        if resolved is not None and resolved[0]:
+            _cache_pm_ver(resolved[0])
+        elif family in PM_TABLE_CMDS:
+            ver = _read_pm_ver_rsmu(family)
+            if ver:
+                _cache_pm_ver(ver)
+
+    if _cached_pm_ver is None or not _cached_pm_ver:
         return None
 
-    status = _transfer_with_retry(msg, rsp, args_base, transfer_op, extra)
-    if status != SMU_OK:
+    ver = _cached_pm_ver & 0xFFFFFFFF
+    if _cached_pm_size is None:
+        _cached_pm_size = TABLE_SIZES.get(ver, DEFAULT_TABLE_SIZE)
+    size = _cached_pm_size
+
+    _update_pm_table(family)
+
+    n = min((size + 7) // 8, 512)
+    with _lock:
+        raw = _execute("ioctl_read_pm_table", [], n)
+
+    if not raw:
+        resolved = _resolve_pm_table()
+        if resolved is not None and resolved[0]:
+            ver = _cache_pm_ver(resolved[0])
+            size = _cached_pm_size or DEFAULT_TABLE_SIZE
+            n = min((size + 7) // 8, 512)
+            _update_pm_table(family)
+            with _lock:
+                raw = _execute("ioctl_read_pm_table", [], n)
+
+    if not raw:
         return None
-    data = _read_physical_memory(phys_addr, size)
-    return (data, ver) if data is not None else None
+
+    data = struct.pack(f"<{len(raw)}q", *raw)[:size]
+    if len(data) < size:
+        data = data + b"\x00" * (size - len(data))
+    return (data, ver)
 
 
 def read_pm_table_version(family: str = "") -> int:
-    r = read_pm_table_full(family)
-    return r[1] if r else 0
+    if _cached_pm_ver:
+        return _cached_pm_ver
+    if _handle is None or _k32 is None:
+        return 0
+    resolved = _resolve_pm_table()
+    if resolved and resolved[0]:
+        return _cache_pm_ver(resolved[0])
+    ver = _read_pm_ver_rsmu(family)
+    if ver:
+        return _cache_pm_ver(ver)
+    return 0
 
 
 def read_pm_table(family: str = "") -> bytes | None:
@@ -408,9 +536,12 @@ def read_pm_table(family: str = "") -> bytes | None:
 
 
 def close() -> None:
-    global _handle, _k32, _pawnio_info_cache
+    global _handle, _k32, _pawnio_info_cache, _cached_pm_ver, _cached_pm_size
     if _handle is not None and _k32 is not None:
         _k32.CloseHandle(ctypes.wintypes.HANDLE(_handle))
     _handle = None
     _k32 = None
     _pawnio_info_cache = _UNSET
+    _cached_pm_ver = None
+    _cached_pm_size = None
+

{zenmaster-1.2.0 → zenmaster-1.2.2/zenmaster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zenmaster
-Version: 1.2.0
+Version: 1.2.2
 Summary: Adjust power management settings for Ryzen CPUs on Linux, Windows, and macOS
 Author-email: oxGorou <lekhanhbinh2901@gmail.com>
 License-Expression: GPL-3.0-only
@@ -193,7 +193,7 @@ print(f"SMN 0x0005A380 = 0x{value:08X}")
 
 ## Technical Comparison: ZenMaster vs. RyzenAdj
 
-| Feature | RyzenAdj | ZenMaster v1.2.0 |
+| Feature | RyzenAdj | ZenMaster v1.2.2 |
 |---|---|---|
 | **Installation** | Compilation from source (`cmake`, `make`, `libpci-dev`) | `pip install zenmaster` (pure Python package) |
 | **Supported Families** | ~15 APU and desktop families | 44 families (Zen 1 to Zen 5/6, Desktop, Mobile, Threadripper, Server EPYC via HSMP) |