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

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,15 +14,19 @@ 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,
+    find_ip_version,
     get_distro,
     get_pretty_distro,
     get_property_pyudev,
@@ -40,6 +49,7 @@ from amd_debug.failures import (
     DevSlpDiskIssue,
     DevSlpHostIssue,
     DMArNotEnabled,
+    DmcubTooOld,
     DmiNotSetup,
     FadtWrong,
     I2CHidBug,
@@ -111,12 +121,41 @@ 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():
+            output = None
+            for cmd in ["di-edid-decode", "edid-decode"]:
+                try:
+                    cmd = ["edid-decode", p]
+                    output = subprocess.check_output(
+                        cmd, stderr=subprocess.DEVNULL
+                    ).decode("utf-8")
+                    break
+                except FileNotFoundError:
+                    self.db.record_debug(f"{cmd} not installed")
+                except subprocess.CalledProcessError as e:
+                    self.db.record_debug(
+                        f"failed to capture edid with {cmd}: {e.output}"
+                    )
+            if not output:
+                self.db.record_prereq("Failed to capture EDID table", "👀")
+            else:
+                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 +206,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 +385,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 +394,74 @@ 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_dpia_pg_dmcub(self):
+        """Check if DMUB is new enough to PG DPIA when no USB4 present"""
+        usb4_found = False
+        for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0340"):
+            usb4_found = True
+            break
+        if usb4_found:
+            self.db.record_debug("USB4 routers found, no need to check DMCUB version")
+            return True
+        # Check if matching DCN present
+        for device in self.pyudev.list_devices(subsystem="pci"):
+            current = None
+            klass = device.properties.get("PCI_CLASS")
+            if klass not in ["30000", "38000"]:
+                continue
+            pci_id = device.properties.get("PCI_ID")
+            if not pci_id.startswith("1002"):
+                continue
+            hw_ver = {"major": 3, "minor": 5, "revision": 0}
+            if not find_ip_version(device.sys_path, "DMU", hw_ver):
+                continue
+
+            # DCN was found, lookup version from sysfs
+            p = os.path.join(device.sys_path, "fw_version", "dmcub_fw_version")
+            if os.path.exists(p):
+                current = int(read_file(p), 16)
+
+            # no sysfs, try to look for version from debugfs
+            if not current:
+                slot = device.properties["PCI_SLOT_NAME"]
+                p = os.path.join(
+                    "/", "sys", "kernel", "debug", "dri", slot, "amdgpu_firmware_info"
+                )
+                contents = read_file(p)
+                for line in contents.split("\n"):
+                    if not line.startswith("DMCUB"):
+                        continue
+                    current = int(line.split()[-1], 16)
+            if current:
+                expected = 0x09001B00
+                if current >= expected:
+                    return True
+                self.db.record_prereq("DMCUB Firmware is outdated", "❌")
+                self.failures += [DmcubTooOld(current, expected)]
+                return False
         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 +574,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 +583,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 +671,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 +704,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 +728,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"
@@ -654,9 +751,13 @@ class PrerequisiteValidator(AmdTool):
             interface = device.properties.get("INTERFACE")
             cmd = ["ethtool", interface]
             wol_supported = False
-            output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
-                "utf-8"
-            )
+            try:
+                output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
+                    "utf-8"
+                )
+            except FileNotFoundError:
+                self.db.record_prereq(f"ethtool is missing", "👀")
+                return True
             for line in output.split("\n"):
                 if "Supports Wake-on" in line:
                     val = line.split(":")[1].strip()
@@ -671,7 +772,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 +829,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 +847,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 +897,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 +940,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 +1005,9 @@ 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 FileNotFoundError as e:
+                    self.db.record_prereq(f"Failed to capture ACPI table: {e}", "👀")
                 except subprocess.CalledProcessError as e:
                     self.db.record_prereq(
                         f"Failed to capture ACPI table: {e.output}", "👀"
@@ -925,10 +1024,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 +1081,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 +1096,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 +1114,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", "❌"
@@ -1064,13 +1158,16 @@ class PrerequisiteValidator(AmdTool):
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
             debug_str += "DMA protection:\n"
-            for dev in self.pyudev.list_devices(
-                subsystem="thunderbolt", DEVTYPE="thunderbolt_domain"
-            ):
-                p = os.path.join(dev.sys_path, "iommu_dma_protection")
-                v = int(read_file(p))
-                debug_str += f"\t{p}: {v}\n"
-                found_dmar = v == 1
+            p = os.path.join("/", "sys", "firmware", "acpi", "tables", "IVRS")
+            with open(p, "rb") as f:
+                data = f.read()
+            if len(data) < 40:
+                raise ValueError(
+                    "IVRS table appears too small to contain virtualization info."
+                )
+            virt_info = struct.unpack_from("I", data, 36)[0]
+            debug_str += f"Virtualization info: 0x{virt_info:x}"
+            found_dmar = (virt_info & 0x2) != 0
             self.db.record_debug(debug_str)
             if not found_dmar:
                 self.db.record_prereq(
@@ -1111,7 +1208,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 +1238,7 @@ class PrerequisiteValidator(AmdTool):
             self.capture_linux_firmware,
             self.capture_logind,
             self.capture_pci_acpi,
+            self.capture_edid,
         ]
         checks = []
 
@@ -1167,6 +1267,7 @@ class PrerequisiteValidator(AmdTool):
                 self.check_smt,
                 self.check_iommu,
                 self.check_asus_rog_ally,
+                self.check_dpia_pg_dmcub,
             ]
 
         checks += [

amd_debug/s2idle.py

@@ -8,7 +8,15 @@ 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 (
+    convert_string_to_bool,
+    colorize_choices,
+    is_root,
+    relaunch_sudo,
+    show_log_info,
+    version,
+    running_ssh,
+)
 
 from amd_debug.validator import SleepValidator
 from amd_debug.installer import Installer
@@ -25,6 +33,7 @@ class Defaults:
     since = date.today() - timedelta(days=60)
     until = date.today() + timedelta(days=1)
     format_choices = ["txt", "md", "html", "stdout"]
+    boolean_choices = ["true", "false"]
 
 
 class Headers:
@@ -40,6 +49,7 @@ class Headers:
     FormatDescription = "What format to output the report in"
     MaxDurationDescription = "What is the maximum suspend cycle length (seconds)"
     MaxWaitDescription = "What is the maximum time between suspend cycles (seconds)"
+    ReportDebugDescription = "Enable debug output in report (increased size)"
 
 
 def display_report_file(fname, fmt) -> None:
@@ -51,12 +61,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]})"
             )
 
 
@@ -76,7 +88,7 @@ def get_report_format() -> str:
     return "html"
 
 
-def prompt_report_arguments(since, until, fname, fmt) -> str:
+def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
     """Prompt user for report configuration"""
     if not since:
         default = Defaults.since
@@ -98,12 +110,23 @@ 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:
             sys.exit(f"Invalid format: {fmt}")
-    return [since, until, get_report_file(fname, fmt), fmt]
+    if report_debug is None:
+        inp = (
+            input(
+                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, "true")})? "
+            )
+            .lower()
+            .capitalize()
+        )
+        report_debug = True if not inp else convert_string_to_bool(inp)
+    return [since, until, get_report_file(fname, fmt), fmt, report_debug]
 
 
 def prompt_test_arguments(duration, wait, count, rand) -> list:
@@ -146,7 +169,9 @@ def prompt_test_arguments(duration, wait, count, rand) -> list:
 def report(since, until, fname, fmt, tool_debug, report_debug) -> bool:
     """Generate a report from previous sleep cycles"""
     try:
-        since, until, fname, fmt = prompt_report_arguments(since, until, fname, fmt)
+        since, until, fname, fmt, report_debug = prompt_report_arguments(
+            since, until, fname, fmt, report_debug
+        )
     except KeyboardInterrupt:
         sys.exit("\nReport generation cancelled")
     try:
@@ -176,12 +201,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
@@ -198,8 +223,8 @@ def test(
         app = SleepValidator(tool_debug=debug, bios_debug=bios_debug)
         try:
             duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
-            since, until, fname, fmt = prompt_report_arguments(
-                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt
+            since, until, fname, fmt, report_debug = prompt_report_arguments(
+                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
             )
         except KeyboardInterrupt:
             sys.exit("\nTest cancelled")
@@ -218,7 +243,7 @@ def test(
             fname=fname,
             fmt=fmt,
             tool_debug=debug,
-            report_debug=True,
+            report_debug=report_debug,
         )
         app.run()
 
@@ -232,7 +257,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 +284,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 +308,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",
@@ -332,7 +361,7 @@ def parse_args():
     )
     report_cmd.add_argument(
         "--report-debug",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         help="Include debug messages in report (WARNING: can significantly increase report size)",
     )
 
@@ -385,7 +414,7 @@ def main():
         )
     elif args.action == "test":
         relaunch_sudo()
-        ret = test(
+        ret = run_test_cycle(
             args.duration,
             args.wait,
             args.count,

amd_debug/sleep_report.py

@@ -432,8 +432,8 @@ class SleepReport(AmdTool):
 
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html and markdown formats
-        if len(self.df.index) > 1 and (self.format == "html" or self.format == "md"):
+        # Build charts in the page for html format
+        if len(self.df.index) > 1 and self.format == "html":
             self.build_battery_chart()
             self.build_hw_sleep_chart()
 

amd_debug/templates/md

@@ -28,12 +28,5 @@ Measured {{ prereq_date }}.
 ## Summary
 {{ summary }}
 
-{% if battery_svg %}
-{{ battery_svg | safe }}
-{% endif %}
-{% if hwsleep_svg %}
-{{ hwsleep_svg | safe }}
-{% endif %}
-
 ## Failures reported
 {{ failures }}

amd_debug/validator.py

@@ -469,12 +469,10 @@ class SleepValidator(AmdTool):
                     )
                 return False
             except FileNotFoundError:
-                self.db.record_cycle_data("HW sleep statistics file missing", "❌")
-                return False
+                self.db.record_debug(f"HW sleep statistics file {p} is missing")
         if not self.hw_sleep_duration:
             self.db.record_cycle_data("Did not reach hardware sleep state", "❌")
-
-        return self.hw_sleep_duration is not None
+        return self.hw_sleep_duration
 
     def capture_command_line(self):
         """Capture the kernel command line to debug"""
@@ -674,7 +672,7 @@ class SleepValidator(AmdTool):
     def prep(self):
         """Prepare the system for suspend testing"""
         self.last_suspend = datetime.now()
-        self.kernel_log.seek_tail()
+        self.kernel_log.seek_tail(self.last_suspend)
         self.db.start_cycle(self.last_suspend)
         self.kernel_duration = 0
         self.hw_sleep_duration = 0

{amd_debug_tools-0.2.0.dist-info → amd_debug_tools-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.0
+Version: 0.2.2
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT
@@ -125,8 +125,9 @@ The following optional arguments are supported for this command:
         --format FORMAT       Format of the report to produce (html, txt or md)
         --report-file         File to write the report to
         --tool-debug          Enable tool debug logging
-        --report-debug        Include debug messages in the report
-
+        --report-debug
+        --no-report-debug
+                              Include debug messages in report (WARNING: can significantly increase report size)
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.