amd-debug-tools 0.2.0__tar.gz → 0.2.1__tar.gz

{amd_debug_tools-0.2.0/src/amd_debug_tools.egg-info → amd_debug_tools-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.0
+Version: 0.2.1
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT

{amd_debug_tools-0.2.0 → amd_debug_tools-0.2.1}/pyproject.toml

@@ -2,9 +2,22 @@
 requires = ["setuptools>=59.8.0", "setuptools-git-versioning>=2.0,<3"]
 build-backend = "setuptools.build_meta"
 
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.package-data]
+amd_debug = ["s2idle-hook"]
+"amd_debug.templates" = ["*"]
+"amd_debug.bash" = ["amd-s2idle"]
+
 [tool.setuptools-git-versioning]
 enabled = true
 
+[tool.coverage.run]
+branch = true
+source = ["src"]
+omit = ["src/launcher.py"]
+
 [project]
 name = "amd-debug-tools"
 authors = [{ name = "Mario Limonciello", email = "superm1@kernel.org" }]
@@ -27,8 +40,13 @@ dependencies = [
     "matplotlib",
     "seaborn",
 ]
-dynamic = ["version", "scripts"]
+dynamic = ["version"]
 license = "MIT"
 
 [project.urls]
 "Homepage" = "https://web.git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git/"
+
+[project.scripts]
+amd-s2idle = "amd_debug:amd_s2idle"
+amd-bios = "amd_debug:amd_bios"
+amd-pstate = "amd_debug:amd_pstate"

amd_debug_tools-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{amd_debug_tools-0.2.0 → amd_debug_tools-0.2.1}/src/amd_debug/common.py

@@ -81,6 +81,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 +97,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()

amd_debug_tools-0.2.1/src/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_tools-0.2.0 → amd_debug_tools-0.2.1}/src/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,7 @@ 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"
     MissingEthtool = "Ethtool is missing"
     InstallAction = "Attempting to install"
     MissingFwupd = "Firmware update library `fwupd` is missing"
@@ -171,6 +176,18 @@ 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 FwupdPackage(DistroPackage):
     """Fwupd package"""
 
@@ -202,14 +219,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 +261,20 @@ class Installer(AmdTool):
                 package = EthtoolPackage()
                 if not package.install():
                     return False
+        if "edid-decode" in self.requirements:
+            try:
+                edid = (
+                    subprocess.call(
+                        ["edid-decode", "--help"], stdout=subprocess.DEVNULL
+                    )
+                    == 255
+                )
+            except FileNotFoundError:
+                edid = False
+            if not edid:
+                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 +427,7 @@ def install_dep_superset() -> bool:
         "pandas",
         "seaborn",
         "tabulate",
+        "edid-decode",
     )
     ret = tool.install_dependencies()
     if ret:

{amd_debug_tools-0.2.0 → amd_debug_tools-0.2.1}/src/amd_debug/prerequisites.py

@@ -1,6 +1,11 @@
 #!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
+"""
+This module contains the s0i3 prerequisite validator for amd-debug-tools.
+"""
+
+import configparser
 import logging
 import os
 import platform
@@ -9,13 +14,16 @@ import shutil
 import subprocess
 import tempfile
 import struct
-import pyudev
 from datetime import datetime
 from packaging import version
 
+import pyudev
+
 from amd_debug.wake import WakeIRQ
+from amd_debug.display import Display
 from amd_debug.kernel import get_kernel_log, SystemdLogger, DmesgLogger
 from amd_debug.common import (
+    apply_prefix_wrapper,
     BIT,
     clear_temporary_message,
     get_distro,
@@ -111,12 +119,37 @@ class PrerequisiteValidator(AmdTool):
         self.irqs = []
         self.smu_version = ""
         self.smu_program = ""
+        self.display = Display()
 
     def capture_once(self):
         """Capture the prerequisites once"""
         if not self.db.get_last_prereq_ts():
             self.run()
 
+    def capture_edid(self):
+        """Capture and decode the EDID data"""
+        edids = self.display.get_edid()
+        if len(edids) == 0:
+            self.db.record_debug("No EDID data found")
+            return True
+
+        for name, p in edids.items():
+            try:
+                cmd = ["edid-decode", p]
+                output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
+                    "utf-8"
+                )
+            except FileNotFoundError:
+                self.db.record_prereq(
+                    "edid-decode not installed, unable to decode EDID", "👀"
+                )
+                return True
+            except subprocess.CalledProcessError as e:
+                self.db.record_prereq(f"Failed to capture EDID table: {e.output}", "👀")
+                return False
+            self.db.record_debug(apply_prefix_wrapper(f"EDID for {name}:", output))
+        return True
+
     def check_amdgpu(self):
         """Check for the AMDGPU driver"""
         for device in self.pyudev.list_devices(subsystem="pci"):
@@ -167,10 +200,10 @@ class PrerequisiteValidator(AmdTool):
         if self.kernel_log.match_pattern("ath11k_pci.*wcn6855"):
             match = self.kernel_log.match_pattern("ath11k_pci.*fw_version")
             if match:
-                self.db.record_debug("WCN6855 version string: %s" % match)
+                self.db.record_debug(f"WCN6855 version string: {match}")
                 objects = match.split()
-                for i in range(0, len(objects)):
-                    if objects[i] == "fw_build_id":
+                for i, obj in enumerate(objects):
+                    if obj == "fw_build_id":
                         wcn6855 = objects[i + 1]
 
         if wcn6855:
@@ -346,6 +379,7 @@ class PrerequisiteValidator(AmdTool):
 
     def check_usb3(self):
         """Check for the USB4 controller"""
+        slots = []
         for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0330"):
             slot = device.properties["PCI_SLOT_NAME"]
             if device.properties.get("DRIVER") != "xhci_hcd":
@@ -354,18 +388,27 @@ class PrerequisiteValidator(AmdTool):
                 )
                 self.failures += [MissingXhciHcd()]
                 return False
-            self.db.record_prereq(f"USB3 driver `xhci_hcd` bound to {slot}", "✅")
+            slots += [slot]
+        if slots:
+            self.db.record_prereq(
+                f"USB3 driver `xhci_hcd` bound to {', '.join(slots)}", "✅"
+            )
         return True
 
     def check_usb4(self):
         """Check if the thunderbolt driver is loaded"""
+        slots = []
         for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0340"):
             slot = device.properties["PCI_SLOT_NAME"]
             if device.properties.get("DRIVER") != "thunderbolt":
                 self.db.record_prereq("USB4 driver `thunderbolt` missing", "❌")
                 self.failures += [MissingThunderbolt()]
                 return False
-            self.db.record_prereq(f"USB4 driver `thunderbolt` bound to {slot}", "✅")
+            slots += [slot]
+        if slots:
+            self.db.record_prereq(
+                f"USB4 driver `thunderbolt` bound to {', '.join(slots)}", "✅"
+            )
         return True
 
     def check_sleep_mode(self):
@@ -478,8 +521,8 @@ class PrerequisiteValidator(AmdTool):
                 continue
             if self.cpu_family and self.cpu_model and self.cpu_model_string:
                 self.db.record_prereq(
-                    "%s (family %x model %x)"
-                    % (self.cpu_model_string, self.cpu_family, self.cpu_model),
+                    f"{self.cpu_model_string} "
+                    f"(family {self.cpu_family:x} model {self.cpu_model:x})",
                     "💻",
                 )
                 break
@@ -487,7 +530,7 @@ class PrerequisiteValidator(AmdTool):
 
     # See https://github.com/torvalds/linux/commit/ec6c0503190417abf8b8f8e3e955ae583a4e50d4
     def check_fadt(self):
-        """Check the kernel emitted a message specific to 6.0 or later indicating FADT had a bit set."""
+        """Check the kernel emitted a message indicating FADT had a bit set."""
         found = False
         if not self.kernel_log:
             message = "Unable to test FADT from kernel log"
@@ -575,10 +618,10 @@ class PrerequisiteValidator(AmdTool):
         """Check if the user has permissions to write to /sys/power/state"""
         p = os.path.join("/", "sys", "power", "state")
         try:
-            with open(p, "w") as w:
+            with open(p, "w", encoding="utf-8") as _w:
                 pass
         except PermissionError:
-            self.db.record_prereq("%s" % Headers.RootError, "👀")
+            self.db.record_prereq(f"{Headers.RootError}", "👀")
             return False
         except FileNotFoundError:
             self.db.record_prereq("Kernel doesn't support power management", "❌")
@@ -608,7 +651,8 @@ class PrerequisiteValidator(AmdTool):
                     )
         if show_warning:
             self.db.record_prereq(
-                "Timer based wakeup doesn't work properly for your ASIC/firmware, please manually wake the system",
+                "Timer based wakeup doesn't work properly for your "
+                "ASIC/firmware, please manually wake the system",
                 "🚦",
             )
         return True
@@ -631,7 +675,7 @@ class PrerequisiteValidator(AmdTool):
                 for line in contents.split("\n"):
                     if "WAKE_INT_MASTER_REG:" in line:
                         val = "en" if int(line.split()[1], 16) & BIT(15) else "dis"
-                        self.db.record_debug("Windows GPIO 0 debounce: %sabled" % val)
+                        self.db.record_debug(f"Windows GPIO 0 debounce: {val}abled")
                         continue
                     if not header and re.search("trigger", line):
                         debug_str += line + "\n"
@@ -671,7 +715,9 @@ class PrerequisiteValidator(AmdTool):
                         self.db.record_prereq(f"{interface} has WoL enabled", "✅")
                     else:
                         self.db.record_prereq(
-                            f"Platform may have low hardware sleep residency with Wake-on-lan disabled. Run `ethtool -s {interface} wol g` to enable it if necessary.",
+                            "Platform may have low hardware sleep residency "
+                            "with Wake-on-lan disabled. Run `ethtool -s "
+                            f"{interface} wol g` to enable it if necessary.",
                             "🚦",
                         )
         return True
@@ -726,7 +772,8 @@ class PrerequisiteValidator(AmdTool):
             # Dictionary of instance id to firmware version mappings that
             # have been "reported" to be problematic
             device_map = {
-                "8c36f7ee-cc11-4a36-b090-6363f54ecac2": "0.1.26",  # https://gitlab.freedesktop.org/drm/amd/-/issues/3443
+                # https://gitlab.freedesktop.org/drm/amd/-/issues/3443
+                "8c36f7ee-cc11-4a36-b090-6363f54ecac2": "0.1.26",
             }
             interesting_plugins = ["nvme", "tpm", "uefi_capsule"]
             if device.get_plugin() in interesting_plugins:
@@ -743,7 +790,8 @@ class PrerequisiteValidator(AmdTool):
                     item in device.get_guids() or item in device.get_instance_ids()
                 ) and ver in device.get_version():
                     self.db.record_prereq(
-                        f"Platform may have problems resuming.  Upgrade the firmware for '{device.get_name()}' if you have problems.",
+                        "Platform may have problems resuming.  Upgrade the "
+                        f"firmware for '{device.get_name()}' if you have problems.",
                         "🚦",
                     )
         return True
@@ -792,12 +840,13 @@ class PrerequisiteValidator(AmdTool):
             else:
                 acpi_hid = ""
             # set prefix if last device
-            prefix = "| " if dev != devices[-1] else "└─"
-            debug_str += "{prefix}{name} [{acpi_hid}] : {acpi_path}\n".format(
-                prefix=prefix, name=name, acpi_hid=acpi_hid, acpi_path=acpi_path
-            )
+            prefix = "│ " if dev != devices[-1] else "└─"
+            debug_str += f"{prefix}{name} [{acpi_hid}] : {acpi_path}\n"
             if "IDEA5002" in name:
-                remediation = f"echo {parent.sys_path.split('/')[-1]} | sudo tee /sys/bus/i2c/drivers/{parent.driver}/unbind"
+                remediation = (
+                    f"echo {parent.sys_path.split('/')[-1]} | "
+                    f"sudo tee /sys/bus/i2c/drivers/{parent.driver}/unbind"
+                )
 
                 self.db.record_prereq(f"{name} may cause spurious wakeups", "❌")
                 self.failures += [I2CHidBug(name, remediation)]
@@ -834,22 +883,13 @@ class PrerequisiteValidator(AmdTool):
             if os.path.exists(p):
                 acpi = read_file(p)
                 debug_str += (
-                    "{prefix}{pci_slot_name} : {vendor} {cls} [{id}] : {acpi}\n".format(
-                        prefix=prefix,
-                        pci_slot_name=pci_slot_name,
-                        vendor=database_vendor,
-                        cls=database_class,
-                        id=pci_id,
-                        acpi=acpi,
-                    )
+                    f"{prefix}{pci_slot_name} : "
+                    f"{database_vendor} {database_class} [{pci_id}] : {acpi}\n"
                 )
             else:
-                debug_str += "{prefix}{pci_slot_name} : {vendor} {cls} [{id}]\n".format(
-                    prefix=prefix,
-                    vendor=database_vendor,
-                    pci_slot_name=pci_slot_name,
-                    cls=database_class,
-                    id=pci_id,
+                debug_str += (
+                    f"{prefix}{pci_slot_name} : "
+                    f"{database_vendor} {database_class} [{pci_id}]\n"
                 )
         if debug_str:
             self.db.record_debug(debug_str)
@@ -908,7 +948,7 @@ class PrerequisiteValidator(AmdTool):
                         stdout=subprocess.DEVNULL,
                         stderr=subprocess.DEVNULL,
                     )
-                    self.db.record_debug_file("%s.dsl" % prefix)
+                    self.db.record_debug_file(f"{prefix}.dsl")
                 except subprocess.CalledProcessError as e:
                     self.db.record_prereq(
                         f"Failed to capture ACPI table: {e.output}", "👀"
@@ -925,10 +965,10 @@ class PrerequisiteValidator(AmdTool):
             self.db.record_prereq(desc, "🔋")
 
     def capture_logind(self):
+        """Capture logind.conf settings"""
         base = os.path.join("/", "etc", "systemd", "logind.conf")
         if not os.path.exists(base):
             return True
-        import configparser
 
         config = configparser.ConfigParser()
         config.read(base)
@@ -982,7 +1022,8 @@ class PrerequisiteValidator(AmdTool):
             _, cpu_count, _, _ = read_cpuid(0, 0x80000026, 1)
             if cpu_count > max_cpus:
                 self.db.record_prereq(
-                    f"The kernel has been limited to {max_cpus} CPU cores, but the system has {cpu_count} cores",
+                    f"The kernel has been limited to {max_cpus} CPU cores, "
+                    f"but the system has {cpu_count} cores",
                     "❌",
                 )
                 self.failures += [LimitedCores(cpu_count, max_cpus)]
@@ -996,12 +1037,6 @@ class PrerequisiteValidator(AmdTool):
         except PermissionError:
             self.db.record_prereq("CPUID checks unavailable", "🚦")
 
-        if valid:
-            self.db.record_prereq(
-                f"{self.cpu_model_string} (family {self.cpu_family:x} model {self.cpu_model:x})",
-                "✅",
-            )
-
         return True
 
     def check_msr(self):
@@ -1020,7 +1055,7 @@ class PrerequisiteValidator(AmdTool):
                 if not check_bits(val, expect_val):
                     self.failures += [MSRFailure()]
                     return False
-                self.db.record_prereq("PC6 and CC6 enabled", "✅")
+            self.db.record_prereq("PC6 and CC6 enabled", "✅")
         except FileNotFoundError:
             self.db.record_prereq(
                 "Unable to check MSRs: MSR kernel module not loaded", "❌"
@@ -1111,7 +1146,9 @@ class PrerequisiteValidator(AmdTool):
         if "pcie_port_pm=off" in cmdline:
             return True
         self.db.record_prereq(
-            "Platform may hang resuming.  Upgrade your firmware or add pcie_port_pm=off to kernel command line if you have problems.",
+            "Platform may hang resuming.  "
+            "Upgrade your firmware or add pcie_port_pm=off to kernel command "
+            "line if you have problems.",
             "🚦",
         )
         return False
@@ -1139,6 +1176,7 @@ class PrerequisiteValidator(AmdTool):
             self.capture_linux_firmware,
             self.capture_logind,
             self.capture_pci_acpi,
+            self.capture_edid,
         ]
         checks = []
 

{amd_debug_tools-0.2.0 → amd_debug_tools-0.2.1}/src/amd_debug/s2idle.py

@@ -8,7 +8,14 @@ import subprocess
 import sqlite3
 
 from datetime import date, timedelta, datetime
-from amd_debug.common import is_root, relaunch_sudo, show_log_info, version, running_ssh
+from amd_debug.common import (
+    colorize_choices,
+    is_root,
+    relaunch_sudo,
+    show_log_info,
+    version,
+    running_ssh,
+)
 
 from amd_debug.validator import SleepValidator
 from amd_debug.installer import Installer
@@ -51,12 +58,14 @@ def display_report_file(fname, fmt) -> None:
         return
     user = os.environ.get("SUDO_USER")
     if user:
-        # ensure that xdg tools will know how to display the file (user may need to call tool with sudo -E)
+        # ensure that xdg tools will know how to display the file
+        # (user may need to call tool with sudo -E)
         if os.environ.get("XDG_SESSION_TYPE"):
             subprocess.call(["sudo", "-E", "-u", user, "xdg-open", fname])
         else:
             print(
-                f"To display report automatically in browser launch tool with '-E' argument (Example: sudo -E {sys.argv[0]})"
+                "To display report automatically in browser launch tool "
+                f"with '-E' argument (Example: sudo -E {sys.argv[0]})"
             )
 
 
@@ -98,7 +107,9 @@ def prompt_report_arguments(since, until, fname, fmt) -> str:
         sys.exit(f"Invalid date, use YYYY-MM-DD: {e}")
 
     if not fmt:
-        fmt = input(f"{Headers.FormatDescription} (default {get_report_format()})? ")
+        fmt = input(
+            f"{Headers.FormatDescription} ({colorize_choices(Defaults.format_choices, get_report_format())})? "
+        )
         if not fmt:
             fmt = get_report_format()
         if fmt not in Defaults.format_choices:
@@ -176,12 +187,12 @@ def report(since, until, fname, fmt, tool_debug, report_debug) -> bool:
     return True
 
 
-def test(
+def run_test_cycle(
     duration, wait, count, fmt, fname, force, debug, rand, logind, bios_debug
 ) -> bool:
     """Run a test"""
     app = Installer(tool_debug=debug)
-    app.set_requirements("iasl", "ethtool")
+    app.set_requirements("iasl", "ethtool", "edid-decode")
     if not app.install_dependencies():
         print("Failed to install dependencies")
         return False
@@ -232,7 +243,7 @@ def test(
 def install(debug) -> None:
     """Install the tool"""
     installer = Installer(tool_debug=debug)
-    installer.set_requirements("iasl", "ethtool")
+    installer.set_requirements("iasl", "ethtool", "edid-decode")
     if not installer.install_dependencies():
         sys.exit("Failed to install dependencies")
     try:
@@ -259,7 +270,8 @@ def parse_args():
     """Parse command line arguments"""
     parser = argparse.ArgumentParser(
         description="Swiss army knife for analyzing Linux s2idle problems",
-        epilog="The tool can run an immediate test with the 'test' command or can be used to hook into systemd for building reports later.\n"
+        epilog="The tool can run an immediate test with the 'test' command "
+        "or can be used to hook into systemd for building reports later.\n"
         "All optional arguments will be prompted if needed.\n"
         "To use non-interactively, please populate all optional arguments.",
     )
@@ -282,7 +294,10 @@ def parse_args():
     test_cmd.add_argument(
         "--random",
         action="store_true",
-        help="Run sleep cycles for random durations and wait, using the --duration and --wait arguments as an upper bound",
+        help=(
+            "Run sleep cycles for random durations and wait, using the "
+            "--duration and --wait arguments as an upper bound",
+        ),
     )
     test_cmd.add_argument(
         "--force",
@@ -385,7 +400,7 @@ def main():
         )
     elif args.action == "test":
         relaunch_sudo()
-        ret = test(
+        ret = run_test_cycle(
             args.duration,
             args.wait,
             args.count,

{amd_debug_tools-0.2.0 → amd_debug_tools-0.2.1/src/amd_debug_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.0
+Version: 0.2.1
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT