amd-debug-tools 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

amd_debug/common.py

@@ -14,6 +14,7 @@ import struct
 import subprocess
 import re
 import sys
+from ast import literal_eval
 from datetime import date, timedelta
 
 
@@ -81,6 +82,15 @@ def print_color(message, group) -> None:
     print(f"{prefix}{color}{message}{suffix}")
 
 
+def colorize_choices(choices, default) -> str:
+    """Output a list of choices with colors, where the default is highlighted"""
+    if default not in choices:
+        raise ValueError(f"Default choice '{default}' not in choices")
+    choices = [c for c in choices if c != default]
+    choices = [f"{Colors.OK}{default}{Colors.ENDC}"] + choices
+    return ", ".join(choices)
+
+
 def fatal_error(message):
     """Prints a fatal error message and exits"""
     _configure_log(None)
@@ -88,6 +98,21 @@ def fatal_error(message):
     sys.exit(1)
 
 
+def apply_prefix_wrapper(header, message):
+    """Apply a prefix to wrap a newline delimitted message"""
+    s = f"{header.strip()}\n"
+    lines = message.strip().split("\n")
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            continue
+        if i == len(lines) - 1:
+            s += f"└─ {line}\n"
+            continue
+        s += f"│ {line}\n"
+    return s
+
+
 def show_log_info():
     """Show log information"""
     logger = logging.getLogger()
@@ -254,6 +279,19 @@ def get_property_pyudev(properties, key, fallback=""):
         return ""
 
 
+def find_ip_version(base_path, kind, hw_ver) -> bool:
+    """Determine if an IP version is present on the system"""
+    b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+    for key, expected_value in hw_ver.items():
+        p = os.path.join(b, key)
+        if not os.path.exists(p):
+            return False
+        v = int(read_file(p))
+        if v != expected_value:
+            return False
+    return True
+
+
 def read_msr(msr, cpu):
     """Read a Model-Specific Register (MSR) value from the CPU."""
     p = f"/dev/cpu/{cpu}/msr"
@@ -284,6 +322,16 @@ def running_ssh():
     return "SSH_CLIENT" in os.environ or "SSH_TTY" in os.environ
 
 
+def convert_string_to_bool(str_value) -> bool:
+    """convert a string to a boolean value"""
+    try:
+        value = literal_eval(str_value)
+    except (SyntaxError, ValueError):
+        value = None
+        sys.exit(f"Invalid entry: {str_value}")
+    return bool(value)
+
+
 def _git_describe() -> str:
     """Get the git description of the current commit"""
     try:

amd_debug/display.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""Display analysis"""
+import os
+from pyudev import Context
+
+from amd_debug.common import read_file
+
+
+class Display:
+    """Display analysis"""
+
+    def __init__(self):
+        self.pyudev = Context()
+        self.edid = {}
+
+        for dev in self.pyudev.list_devices(subsystem="drm"):
+            if not "card" in dev.device_path:
+                continue
+            p = os.path.join(dev.sys_path, "status")
+            if not os.path.exists(p):
+                continue
+            f = read_file(p)
+            if f != "connected":
+                continue
+            p = os.path.join(dev.sys_path, "enabled")
+            f = read_file(p)
+            if f != "enabled":
+                continue
+            self.edid[dev.sys_name] = os.path.join(dev.sys_path, "edid")
+
+    def get_edid(self) -> list:
+        """Get the path for EDID data for all connected displays"""
+        return self.edid

amd_debug/failures.py

@@ -416,7 +416,7 @@ class LowHardwareSleepResidency(S0i3Failure):
         super().__init__()
         self.description = "System had low hardware sleep residency"
         self.explanation = (
-            f"The system was asleep for {timedelta(seconds=duration)}, but only spent {percent:.2%} "
+            f"The system was asleep for {timedelta(seconds=duration)}, but only spent {percent/100:.2%} "
             "of this time in a hardware sleep state.  In sleep cycles that are at least "
             "60 seconds long it's expected you spend above 90 percent of the cycle in "
             "hardware sleep."
@@ -586,3 +586,15 @@ class RogAllyMcuPowerSave(S0i3Failure):
             "The MCU powersave feature is disabled which will cause problems "
             "with the controller after suspend/resume."
         )
+
+
+class DmcubTooOld(S0i3Failure):
+    """DMCUB microcode is too old"""
+
+    def __init__(self, current, expected):
+        super().__init__()
+        self.description = "DMCUB microcode is too old"
+        self.explanation = (
+            f"The DMCUB microcode version {hex(current)} is older than the"
+            f"minimum suggested version {hex(expected)}."
+        )

amd_debug/installer.py

@@ -1,6 +1,10 @@
 #!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
+"""
+This module contains installer support for amd-debug-tools.
+"""
+
 import argparse
 import os
 import shutil
@@ -21,6 +25,8 @@ class Headers:  # pylint: disable=too-few-public-methods
     """Headers for the script"""
 
     MissingIasl = "ACPI extraction tool `iasl` is missing"
+    MissingEdidDecode = "EDID decoding tool `edid-decode` is missing"
+    MissingDiEdidDecode = "EDID decoding tool `di-edid-decode` is missing"
     MissingEthtool = "Ethtool is missing"
     InstallAction = "Attempting to install"
     MissingFwupd = "Firmware update library `fwupd` is missing"
@@ -30,6 +36,7 @@ class Headers:  # pylint: disable=too-few-public-methods
     MissingTabulate = "Data library `tabulate` is missing"
     MissingJinja2 = "Template library `jinja2` is missing"
     MissingSeaborn = "Data visualization library `seaborn` is missing"
+    UnknownDistro = "No distro installation support available, install manually"
 
 
 class DistroPackage:
@@ -66,7 +73,8 @@ class DistroPackage:
                 return False
             installer = ["pacman", "-Sy", self.arch]
         else:
-            return False
+            print_color(Headers.UnknownDistro, "👀")
+            return True
 
         try:
             subprocess.check_call(installer)
@@ -171,6 +179,30 @@ class EthtoolPackage(DistroPackage):
         )
 
 
+class EdidDecodePackage(DistroPackage):
+    """Edid-Decode package"""
+
+    def __init__(self):
+        super().__init__(
+            deb="edid-decode",
+            rpm="edid-decode",
+            arch=None,
+            message=Headers.MissingEdidDecode,
+        )
+
+
+class DisplayInfoPackage(DistroPackage):
+    """display info package"""
+
+    def __init__(self):
+        super().__init__(
+            deb="libdisplay-info-bin",
+            rpm="libdisplay-info",
+            arch="libdisplay-info",
+            message=Headers.MissingDiEdidDecode,
+        )
+
+
 class FwupdPackage(DistroPackage):
     """Fwupd package"""
 
@@ -202,14 +234,14 @@ class Installer(AmdTool):
         # test if fwupd can report device firmware versions
         try:
             import gi  # pylint: disable=import-outside-toplevel
-            from gi.repository import (
+            from gi.repository import (  # pylint: disable=import-outside-toplevel
                 GLib as _,
-            )  # pylint: disable=import-outside-toplevel
+            )
 
             gi.require_version("Fwupd", "2.0")
-            from gi.repository import (
+            from gi.repository import (  # pylint: disable=import-outside-toplevel
                 Fwupd as _,
-            )  # pylint: disable=import-outside-toplevel
+            )
 
             self.fwupd = True
         except ImportError:
@@ -244,6 +276,37 @@ class Installer(AmdTool):
                 package = EthtoolPackage()
                 if not package.install():
                     return False
+        # can be satisified by either edid-decode or di-edid-decode
+        if "edid-decode" in self.requirements:
+            try:
+                di_edid = (
+                    subprocess.call(
+                        ["di-edid-decode", "--help"],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    == 255
+                )
+            except FileNotFoundError:
+                di_edid = False
+            try:
+                edid = (
+                    subprocess.call(
+                        ["edid-decode", "--help"], stdout=subprocess.DEVNULL
+                    )
+                    == 255
+                )
+            except FileNotFoundError:
+                edid = False
+            if not di_edid and not edid:
+                # try to install di-edid-decode first
+                package = DisplayInfoPackage()
+                if package.install():
+                    return True
+                # fall back to edid-decode instead
+                package = EdidDecodePackage()
+                if not package.install():
+                    return False
         if "fwupd" in self.requirements and not self.fwupd:
             package = FwupdPackage()
             if not package.install():
@@ -396,6 +459,7 @@ def install_dep_superset() -> bool:
         "pandas",
         "seaborn",
         "tabulate",
+        "edid-decode",
     )
     ret = tool.install_dependencies()
     if ret: