trcc-linux 9.7.6__tar.gz → 9.7.7__tar.gz

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.7.6
+Version: 9.7.7
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.6"
+version = "9.7.7"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -136,6 +136,9 @@ artifacts = [
     "**/assets/**/*.service",
     "**/assets/**/*.policy",
     "**/assets/**/*.svg",
+    # Privileged MCHBAR timing reader (no extension) — distro packages install
+    # it to /usr/bin/trcc-imc; shipped here so it's in the sdist/wheel too.
+    "**/assets/trcc-imc",
     # SELinux policy source — `trcc system setup` builds + loads it on Fedora
     # so source/pip installs can pass the USB/SCSI ioctls (packages ship the
     # compiled .pp via the rpm).

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.7.6"
+__version__ = "9.7.7"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/adapters/sensors/aggregator.py

@@ -29,6 +29,7 @@ from ...core.models import MIN_REFRESH_INTERVAL_S, SensorReading
 from ...core.ports import (
     CpuSource,
     DiskSource,
+    DramSource,
     FanSource,
     GpuSource,
     MemorySource,
@@ -36,8 +37,10 @@ from ...core.ports import (
 )
 from .hwmon import (
     HwmonCpu,
+    SpdClock,
     discover_amd_gpus,
     discover_disk_temp,
+    discover_dram_temp,
     discover_fans,
     discover_intel_gpus,
     find_cpu_temp_device,
@@ -73,6 +76,8 @@ def _memory_keys() -> list[tuple[str, str, str]]:
         ("memory:available", "memory", "MB"),
         ("memory:total", "memory", "MB"),
         ("memory:percent", "memory", "%"),
+        ("memory:temp", "temperature", "°C"),
+        ("memory:clock", "clock", "MHz"),
     ]
 
 
@@ -129,6 +134,8 @@ class BaselineSensors(SensorEnumerator):
                  gpus: list[GpuSource] | None = None,
                  fans: list[FanSource] | None = None,
                  disks: list[DiskSource] | None = None,
+                 dram: list[DramSource] | None = None,
+                 spd_clock: SpdClock | None = None,
                  thread_context: Callable[[], AbstractContextManager[None]]
                      = nullcontext) -> None:
         self._cpu = cpu or PsutilCpu()
@@ -136,6 +143,8 @@ class BaselineSensors(SensorEnumerator):
         self._gpus: list[GpuSource] = gpus if gpus is not None else discover_nvidia_gpus()
         self._fans: list[FanSource] = fans or []
         self._disks: list[DiskSource] = disks or []
+        self._dram: list[DramSource] = dram or []
+        self._spd_clock = spd_clock
         # Per-thread OS setup the poll thread enters before touching OS
         # sensor APIs (Windows → COM apartment for WMI; others → no-op).
         # Injected as a narrow callable so this OS-neutral aggregator never
@@ -367,6 +376,20 @@ class BaselineSensors(SensorEnumerator):
         if disk_temps:
             _store(r, "disk:temp", max(disk_temps))
 
+        # DRAM temperature — one DramSource per DIMM; the model carries a single
+        # ``mem_temp`` slot, so collapse to the HOTTEST module, mirroring disk.
+        dram_temps = [
+            t for d in self._dram
+            if (t := self._read(d.temp, f"memory:{d.key}:temp")) is not None
+        ]
+        if dram_temps:
+            _store(r, "memory:temp", max(dram_temps))
+
+        # Memory channel clock — static SPD nameplate (cached at construction).
+        if self._spd_clock is not None:
+            _store(r, "memory:clock",
+                   self._read(self._spd_clock.clock, "memory:clock"))
+
         # IO + time
         try:
             self._io.poll(r)
@@ -415,8 +438,12 @@ def build_linux_sensors() -> BaselineSensors:
     gpus.extend(discover_intel_gpus(hwmon_devices))
     fans = discover_fans(hwmon_devices)
     disks = discover_disk_temp(hwmon_devices)
-    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d, disks=%d",
+    dram = discover_dram_temp(hwmon_devices)
+    spd_clock = SpdClock()
+    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d, disks=%d, dram=%d, "
+             "mem_clock=%s",
              "yes" if cpu.temp() is not None else "no",
-             len(gpus), len(fans), len(disks))
+             len(gpus), len(fans), len(disks), len(dram), spd_clock.clock())
     return BaselineSensors(cpu=cpu, memory=PsutilMemory(),
-                           gpus=gpus, fans=fans, disks=disks)
+                           gpus=gpus, fans=fans, disks=disks, dram=dram,
+                           spd_clock=spd_clock)

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/adapters/sensors/hwmon.py

@@ -24,7 +24,7 @@ import threading
 import time
 from pathlib import Path
 
-from ...core.ports import CpuSource, DiskSource, FanSource, GpuSource
+from ...core.ports import CpuSource, DiskSource, DramSource, FanSource, GpuSource
 from .psutil_sources import PsutilCpu
 
 log = logging.getLogger(__name__)
@@ -505,3 +505,70 @@ def discover_disk_temp(devices: list[HwmonDevice]) -> list[DiskSource]:
         label = _read_text(dev.path / "temp1_label")
         disks.append(HwmonDisk(dev, label))
     return disks
+
+
+# ── Memory (DRAM SPD-hub) temperature ────────────────────────────────
+
+# hwmon drivers that expose a DIMM thermal sensor: DDR5 modules carry an
+# integrated SPD-hub sensor (``spd5118``); DDR4 modules expose the optional
+# JEDEC JC-42.4 thermal sensor (``jc42``).  ``ee1004`` (the DDR4 SPD EEPROM)
+# is deliberately excluded — it carries identity data, not a temperature.
+_DRAM_DRIVERS = ("spd5118", "jc42")
+
+
+class HwmonDram(DramSource):
+    """One DIMM's temp1 sensor on a hwmon ``spd5118`` / ``jc42`` node."""
+
+    def __init__(self, hwmon: HwmonDevice, label: str | None) -> None:
+        self._hwmon = hwmon
+        self._label = label or f"{hwmon.driver} DRAM"
+
+    @property
+    def key(self) -> str:
+        # Include the hwmon dir name: matched DIMMs share a driver, so a
+        # driver-only key would collide across modules (and conflate their
+        # per-source read-failure bookkeeping).
+        return f"hwmon:{self._hwmon.driver}:{self._hwmon.path.name}:temp1"
+
+    @property
+    def name(self) -> str:
+        return self._label
+
+    def temp(self) -> float | None:
+        return self._hwmon.read_temp(1)
+
+
+def discover_dram_temp(devices: list[HwmonDevice]) -> list[DramSource]:
+    """One :class:`HwmonDram` per ``spd5118`` / ``jc42`` device with a temp1."""
+    log.info("discover_dram_temp: devices=%d", len(devices))
+    dram: list[DramSource] = []
+    for dev in devices:
+        if dev.driver not in _DRAM_DRIVERS:
+            continue
+        if dev.read_temp(1) is None:
+            log.debug("discover_dram_temp: %s has no temp1_input — skip", dev.driver)
+            continue
+        label = _read_text(dev.path / "temp1_label")
+        dram.append(HwmonDram(dev, label))
+    return dram
+
+
+# ── Memory channel clock (DDR5 SPD, rootless one-shot) ───────────────
+
+
+class SpdClock:
+    """Memory channel clock (MHz) decoded once from the DDR5 SPD EEPROM.
+
+    The clock is a static nameplate value, so it is read+decoded a single
+    time at construction and cached — ``clock()`` is then a cheap accessor the
+    aggregator can call every poll tick without touching sysfs.
+    """
+
+    def __init__(self) -> None:
+        from ..system.spd import read_spd_timings
+        timings = read_spd_timings()
+        self._mhz: float | None = float(timings.mhz) if timings else None
+        log.info("SpdClock: mhz=%s", self._mhz)
+
+    def clock(self) -> float | None:
+        return self._mhz

trcc_linux-9.7.7/src/trcc/adapters/system/_imc_timings.py

@@ -0,0 +1,71 @@
+"""Decode Intel (Alder/Raptor Lake) MCHBAR memory-timing registers — pure.
+
+The privileged ``trcc-imc`` helper reads four raw MCHBAR registers as root and
+prints them; this module turns those integers into cycle-count timings.  No
+I/O, no root, no OS calls — just bit math — so it is unit-testable with the
+register values captured from real hardware.
+
+Register map (channel 0; CoreFreq ``x86_64/intel_reg.h``):
+
+    BIOS_DDR @0x5E00  mult[7:0]                       → MT/s = mult * 100 * 2
+    TC_PRE   @0xE000  tRP[7:0]  tRAS[50:42] tRCD[58:51]
+    ODT      @0xE070  tCL[22:16] tCWL[31:24]
+    REFRESH  @0xE43C  tREFI[17:0] tRFC[30:18]
+
+``tRC`` has no register — it is the standard ``tRAS + tRP``.  The ``tRFC`` here
+is the controller's live tRFC2 (2x fine-grained refresh), distinct from the
+SPD tRFC1; callers decide which to display.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ImcTimings:
+    """Live primary timings (cycle counts) read from the IMC."""
+
+    mts: int          # effective data rate (MT/s)
+    tcas: int
+    tcwl: int
+    trcd: int
+    trp: int
+    tras: int
+    trc: int
+    trfc: int         # tRFC2 (live refresh) — NOT the SPD tRFC1
+
+
+def _bits(value: int, hi: int, lo: int) -> int:
+    return (value >> lo) & ((1 << (hi - lo + 1)) - 1)
+
+
+def decode_adl(tc_pre: int, odt: int, refresh: int, bios_ddr: int) -> ImcTimings | None:
+    """Decode the four ADL/RPL MCHBAR registers, or ``None`` if implausible.
+
+    The range checks are the caller's defence-in-depth bounds check: a misread
+    register (wrong CPU map, garbage MCHBAR base) yields absurd values, which we
+    reject rather than show.
+    """
+    timings = ImcTimings(
+        mts=(bios_ddr & 0xFF) * 100 * 2,
+        tcas=_bits(odt, 22, 16),
+        tcwl=_bits(odt, 31, 24),
+        trcd=_bits(tc_pre, 58, 51),
+        trp=_bits(tc_pre, 7, 0),
+        tras=_bits(tc_pre, 50, 42),
+        trc=_bits(tc_pre, 50, 42) + _bits(tc_pre, 7, 0),
+        trfc=_bits(refresh, 30, 18),
+    )
+    if not (3200 <= timings.mts <= 8400
+            and 0 < timings.tcas < 128 and 0 < timings.trcd < 128
+            and 0 < timings.trp < 128 and 0 < timings.tras < 256
+            and 0 < timings.trfc < 4096):
+        log.warning("decode_adl: implausible timings %s — rejected", timings)
+        return None
+    log.info("decode_adl: %d MT/s  %d-%d-%d-%d tRC=%d tRFC2=%d",
+             timings.mts, timings.tcas, timings.trcd, timings.trp,
+             timings.tras, timings.trc, timings.trfc)
+    return timings

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/adapters/system/linux.py

@@ -16,9 +16,13 @@ import ctypes
 import logging
 import os
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import usb.util
 
+if TYPE_CHECKING:
+    from ._imc_timings import ImcTimings
+
 from ...core.errors import TransportError
 from ...core.models import DeviceInfo
 from ...core.ports import (
@@ -569,6 +573,11 @@ _DMI_MEMORY_FIELDS: frozenset[str] = frozenset({
 
 _POLKIT_POLICY = '/usr/share/polkit-1/actions/com.github.lexonight1.trcc.policy'
 
+# Privileged MCHBAR reader (installed by the distro packages).  Intel family-6
+# Alder Lake (0x97/0x9A) + Raptor Lake (0xB7/0xBA/0xBF) share the register map.
+_IMC_HELPER = '/usr/bin/trcc-imc'
+_ADL_RPL_MODELS = frozenset({0x97, 0x9A, 0xB7, 0xBA, 0xBF})
+
 
 def _privileged_cmd(binary: str, args: list[str]) -> list[str]:
     """Build a command, wrapping in pkexec when polkit policy is installed."""
@@ -582,6 +591,131 @@ def _privileged_cmd(binary: str, args: list[str]) -> list[str]:
     return [binary, *args]
 
 
+def _enrich_with_spd_timings(slots: list[dict[str, str]]) -> None:
+    """Add DDR5 SPD timings (tcas..trfc) to every slot, in place.
+
+    dmidecode does not expose CAS timings; the DDR5 SPD EEPROM does.  Matched
+    DIMMs share timings, so one rootless SPD read covers the whole channel.
+    Failure (non-DDR5, no spd5118, permissions) leaves slots untouched → "NC".
+    """
+    if not slots:
+        return
+    from .spd import read_spd_timings
+    t = read_spd_timings()
+    if t is None:
+        log.info("_enrich_with_spd_timings: no DDR5 SPD timings available")
+        return
+    fields = {'tcas': t.tcas, 'trcd': t.trcd, 'trp': t.trp,
+              'tras': t.tras, 'trc': t.trc, 'trfc': t.trfc}
+    log.info("_enrich_with_spd_timings: %s", fields)
+    for slot in slots:
+        for key, val in fields.items():
+            slot[key] = str(val)
+
+
+# Sentinel so a failed/unsupported live read is cached too (timings are static
+# per boot; PlatformFactory builds a fresh LinuxPlatform each call, so the cache
+# lives at module scope, not on the instance).
+_UNREAD: object = object()
+_live_imc_cache: object = _UNREAD
+
+
+def _cpu_is_adl_rpl() -> bool:
+    """Rootless: True iff /proc/cpuinfo is an Intel family-6 Alder/Raptor Lake."""
+    family = model = None
+    try:
+        with Path("/proc/cpuinfo").open() as f:
+            for line in f:
+                if line.startswith("vendor_id") and "GenuineIntel" not in line:
+                    return False
+                if line.startswith("cpu family"):
+                    family = int(line.split(":")[1])
+                elif line.startswith("model") and "name" not in line:
+                    model = int(line.split(":")[1])
+                if line == "\n":          # end of the first processor block
+                    break
+    except (OSError, ValueError):
+        return False
+    return family == 6 and model in _ADL_RPL_MODELS
+
+
+def _read_live_imc_timings() -> ImcTimings | None:
+    """Live IMC timings via the privileged ``trcc-imc`` helper, cached for life.
+
+    Silent by design: only spawns the helper when the polkit policy + helper are
+    installed (packaged installs) so it never prompts for a password.  Any
+    failure (unsupported CPU, no policy, bad output) caches ``None`` so we never
+    re-spawn on the next ``memory_info()`` call.
+    """
+    global _live_imc_cache
+    if _live_imc_cache is not _UNREAD:
+        return _live_imc_cache  # type: ignore[return-value]
+    _live_imc_cache = None      # cache the negative result up front
+
+    if os.environ.get("TRCC_DISABLE_LIVE_IMC"):
+        return None
+    if not _cpu_is_adl_rpl() or not Path(_IMC_HELPER).is_file():
+        return None
+
+    import shutil
+    import subprocess
+    if hasattr(os, "geteuid") and os.geteuid() == 0:
+        cmd = [_IMC_HELPER]
+    elif Path(_POLKIT_POLICY).is_file() and shutil.which("pkexec"):
+        cmd = ["pkexec", _IMC_HELPER]
+    else:
+        return None             # no silent privilege path available
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True,
+                                timeout=5, check=False)
+    except (OSError, subprocess.SubprocessError) as e:
+        log.debug("_read_live_imc_timings: helper failed: %s", type(e).__name__)
+        return None
+    if result.returncode != 0:
+        log.info("_read_live_imc_timings: helper exit=%d", result.returncode)
+        return None
+
+    regs: dict[str, int] = {}
+    for token in result.stdout.split():
+        key, _, val = token.partition("=")
+        if key in ("tc_pre", "odt", "refresh", "bios_ddr"):
+            try:
+                regs[key] = int(val, 16)
+            except ValueError:
+                log.warning("_read_live_imc_timings: bad token %r", token)
+                return None
+    if len(regs) != 4:
+        log.warning("_read_live_imc_timings: incomplete helper output")
+        return None
+
+    from ._imc_timings import decode_adl
+    timings = decode_adl(regs["tc_pre"], regs["odt"],
+                         regs["refresh"], regs["bios_ddr"])
+    _live_imc_cache = timings
+    return timings
+
+
+def _enrich_with_live_imc_timings(slots: list[dict[str, str]]) -> None:
+    """Override the SPD timings with the live IMC values, in place.
+
+    Overrides tcas/trcd/trp/tras/trc; the SPD ``trfc`` (tRFC1) is kept — the live
+    register is tRFC2 (2x refresh), a different parameter, so overwriting it
+    would silently mislabel the panel.  No live read → SPD values stand.
+    """
+    if not slots:
+        return
+    t = _read_live_imc_timings()
+    if t is None:
+        return
+    fields = {'tcas': t.tcas, 'trcd': t.trcd, 'trp': t.trp,
+              'tras': t.tras, 'trc': t.trc}
+    log.info("_enrich_with_live_imc_timings: %s", fields)
+    for slot in slots:
+        for key, val in fields.items():
+            slot[key] = str(val)
+
+
 def _linux_memory_info() -> list[dict[str, str]]:
     """Get DRAM slot info via dmidecode; falls back to psutil for totals."""
     log.debug("_linux_memory_info: called")
@@ -611,6 +745,9 @@ def _linux_memory_info() -> list[dict[str, str]]:
     except (OSError, subprocess.SubprocessError) as e:
         log.debug("dmidecode -t memory failed: %s", type(e).__name__)
 
+    _enrich_with_spd_timings(slots)
+    _enrich_with_live_imc_timings(slots)
+
     if not slots:
         try:
             import psutil

trcc_linux-9.7.7/src/trcc/adapters/system/spd.py

@@ -0,0 +1,156 @@
+"""DDR5 SPD (Serial Presence Detect) block-0 decoder — pure, no root.
+
+The DDR5 SPD-hub EEPROM is exposed by the kernel ``spd5118`` driver at
+``/sys/class/hwmon/hwmonN/device/eeprom`` (equivalently
+``/sys/bus/i2c/devices/<bus>-00<addr>/eeprom``).  Reading the FULL 1024-byte
+region fails with ``ENXIO`` on many boards (the SPD hub paginates), but the
+first 128 bytes — JEDEC "block 0", which holds every base timing — read
+reliably and **without root** (the sysfs attribute is world-readable).
+
+This module reads only those 128 bytes and decodes the JEDEC base-profile
+timings (JESD400-5).  The values are the SPD-programmed JEDEC profile, NOT the
+live XMP/EXPO timings the memory controller may actually run — Linux has no
+HWiNFO-equivalent live IMC read, so the SPD profile is the best rootless source.
+
+Byte map (DDR5, JESD400-5; all 16-bit little-endian):
+
+    2       DRAM type (0x12 = DDR5)
+    20-21   tCKAVGmin       (picoseconds)  → clock / data rate
+    30-31   tAAmin (tCAS)   (picoseconds)
+    32-33   tRCDmin         (picoseconds)
+    34-35   tRPmin          (picoseconds)
+    36-37   tRASmin         (picoseconds)
+    38-39   tRCmin          (picoseconds)
+    42-43   tRFC1min        (NANOSECONDS — note the unit differs from the above)
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+_BLOCK0_LEN = 128
+_DDR5_TYPE = 0x12
+
+# Glob roots for the spd5118 SPD-hub EEPROM (both views point at one inode).
+_I2C_ROOT = Path("/sys/bus/i2c/devices")
+_HWMON_ROOT = Path("/sys/class/hwmon")
+
+
+@dataclass(frozen=True)
+class SpdTimings:
+    """Decoded DDR5 base-profile speed + primary timings (cycle counts)."""
+
+    dram_type: str
+    mhz: int          # channel clock (MHz)
+    mts: int          # effective data rate (MT/s)
+    tcas: int
+    trcd: int
+    trp: int
+    tras: int
+    trc: int
+    trfc: int
+
+
+def discover_spd_eeprom_paths() -> list[Path]:
+    """Existing SPD-hub ``eeprom`` files, de-duplicated by resolved target.
+
+    Matched DIMMs share identical timings, so callers may decode ``[0]``.
+    """
+    log.info("discover_spd_eeprom_paths: scanning")
+    candidates: list[Path] = []
+    candidates.extend(_I2C_ROOT.glob("*-005[0-9a-f]/eeprom"))
+    candidates.extend(_HWMON_ROOT.glob("hwmon*/device/eeprom"))
+    seen: set[Path] = set()
+    paths: list[Path] = []
+    for c in candidates:
+        if not c.is_file():
+            continue
+        try:
+            target = c.resolve()
+        except OSError:
+            target = c
+        if target in seen:
+            continue
+        seen.add(target)
+        paths.append(c)
+    log.info("discover_spd_eeprom_paths: %d eeprom(s)", len(paths))
+    return paths
+
+
+def read_spd_block0(path: Path) -> bytes | None:
+    """Read EXACTLY the first 128 bytes of an SPD EEPROM, or ``None``.
+
+    Never reads the whole file — a full read triggers ``ENXIO`` on paginated
+    SPD hubs.  Returns ``None`` on any I/O error or a short read.
+    """
+    try:
+        with path.open("rb", buffering=0) as f:
+            f.seek(0)
+            raw = f.read(_BLOCK0_LEN)
+    except OSError as e:
+        log.debug("read_spd_block0: %s unreadable (%s)", path, type(e).__name__)
+        return None
+    if len(raw) < _BLOCK0_LEN:
+        log.debug("read_spd_block0: %s short read (%d bytes)", path, len(raw))
+        return None
+    return raw
+
+
+def _u16(raw: bytes, off: int) -> int:
+    """16-bit little-endian value at ``off``."""
+    return raw[off] | (raw[off + 1] << 8)
+
+
+def decode_block0(raw: bytes) -> SpdTimings | None:
+    """Decode DDR5 block-0 timings, or ``None`` for non-DDR5 / short input.
+
+    Timings are picosecond values divided by the cycle time and rounded to the
+    nearest whole cycle — round-to-nearest is robust against the ±1 ps
+    quantisation of the stored ``tCKAVGmin`` (a plain ``ceil`` would report
+    CL41 where the JEDEC profile is CL40).
+    """
+    if len(raw) < _BLOCK0_LEN:
+        log.debug("decode_block0: short input (%d bytes)", len(raw))
+        return None
+    if raw[2] != _DDR5_TYPE:
+        # DDR4 (ee1004) uses a different byte map — not decoded yet.
+        log.debug("decode_block0: dram type 0x%02x not DDR5 — skipped", raw[2])
+        return None
+
+    tck = _u16(raw, 20)
+    if tck <= 0:
+        log.warning("decode_block0: invalid tCKAVGmin=%d", tck)
+        return None
+
+    def cycles_from_ps(off: int) -> int:
+        return round(_u16(raw, off) / tck)
+
+    timings = SpdTimings(
+        dram_type="DDR5",
+        mhz=round(1_000_000 / tck),
+        mts=round(2_000_000 / tck),
+        tcas=cycles_from_ps(30),
+        trcd=cycles_from_ps(32),
+        trp=cycles_from_ps(34),
+        tras=cycles_from_ps(36),
+        trc=cycles_from_ps(38),
+        # tRFC1 (byte 42) is stored in NANOSECONDS, unlike the ps fields above.
+        trfc=round(_u16(raw, 42) * 1000 / tck),
+    )
+    log.info("decode_block0: DDR5 %d MT/s  %d-%d-%d-%d tRC=%d tRFC=%d",
+             timings.mts, timings.tcas, timings.trcd, timings.trp,
+             timings.tras, timings.trc, timings.trfc)
+    return timings
+
+
+def read_spd_timings() -> SpdTimings | None:
+    """Decode the first discoverable DDR5 SPD EEPROM, or ``None``."""
+    for path in discover_spd_eeprom_paths():
+        if (raw := read_spd_block0(path)) is not None:
+            if (decoded := decode_block0(raw)) is not None:
+                return decoded
+    log.info("read_spd_timings: no decodable DDR5 SPD found")
+    return None

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/app.py

@@ -34,6 +34,7 @@ from .core.events import (
     OverlayChanged,
     SensorsUpdated,
     SplitModeChanged,
+    SystemResumed,
     TempUnitChanged,
     TimeFormatChanged,
     VideoStarted,
@@ -213,6 +214,15 @@ class App:
         # an active theme/mask stayed pinned to the landscape dir.  Core-level so
         # CLI / API / GUI / daemon all benefit.
         self.events.subscribe(OrientationChanged, self._on_orientation_changed)
+        # Resume-from-suspend: the USB transport a device opened before the
+        # machine slept is stale on wake — writes silently no-op (or the
+        # consecutive-failure recovery never trips), so the panel stays blank
+        # until a manual restart (#189).  Reconnect every attached device on
+        # ``SystemResumed`` (published by the logind PrepareForSleep listener);
+        # ConnectDevice reopens the transport and emits DeviceConnected, after
+        # which the metrics / LED-animation loops and render observers resume on
+        # their own.  Core-level so the daemon, GUI and CLI all recover.
+        self.events.subscribe(SystemResumed, self._on_system_resumed)
         # Hotplug listener — caller (daemon, GUI launcher, tests) decides
         # whether to ``start_hotplug``.  In-process CLI scripts that
         # only do one Command don't need it; the daemon and GUI do.
@@ -247,6 +257,36 @@ class App:
         from .core.commands import ConnectDevice
         self.dispatch(ConnectDevice(key=event.key))
 
+    def _on_system_resumed(self, _event: Any) -> None:
+        """``SystemResumed`` → reconnect every attached device after wake.
+
+        Runs on the power-listener thread — the same off-main-thread pattern
+        ``_on_device_attached`` uses to dispatch ``ConnectDevice``.  The device
+        is already in ``self.devices`` with a STALE transport, so we rebuild it
+        like a replug: stop the old send worker (it is bound to the dead device),
+        release the stale transport, then ``ConnectDevice`` re-attaches a fresh
+        device + transport, re-handshakes, starts a new sender and emits
+        ``DeviceConnected``.  We deliberately do NOT ``detach`` — that would drop
+        the active theme / LED runtime and the panel would come back blank;
+        keeping them lets the metrics / LED-animation loops and render observers
+        repaint the same content on the next tick.  So both the LED segment
+        displays and the LCD panels recover without a manual restart (#189).
+        """
+        from .core.commands import ConnectDevice
+        keys = list(self.devices)
+        log.info("_on_system_resumed: reconnecting %d device(s) after wake", len(keys))
+        for key in keys:
+            old = self.devices.get(key)
+            log.info("_on_system_resumed: %s — stale transport after suspend, "
+                     "stop sender + reopen", key)
+            self.stop_sender(key)
+            if old is not None:
+                try:
+                    old.disconnect()
+                except Exception:
+                    log.exception("_on_system_resumed: disconnect %s raised", key)
+            self.dispatch(ConnectDevice(key=key))
+
     def _on_orientation_changed(self, event: Any) -> None:
         """``OrientationChanged`` → reload the active theme + mask from the
         orientation-keyed resolution dir.

{trcc_linux-9.7.6 → trcc_linux-9.7.7}/src/trcc/assets/com.github.lexonight1.trcc.policy

@@ -29,4 +29,16 @@
     <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/smartctl</annotate>
     <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate>
   </action>
+
+  <action id="com.github.lexonight1.trcc.imc">
+    <description>Read memory-controller timings (IMC/MCHBAR)</description>
+    <message>TRCC needs to read memory-controller timings.</message>
+    <defaults>
+      <allow_any>auth_admin_keep</allow_any>
+      <allow_inactive>auth_admin_keep</allow_inactive>
+      <allow_active>yes</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/trcc-imc</annotate>
+    <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate>
+  </action>
 </policyconfig>