amd-debug-tools 0.2.1__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
 
 
@@ -278,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"
@@ -308,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/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

@@ -26,6 +26,7 @@ class Headers:  # pylint: disable=too-few-public-methods
 
     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"
@@ -35,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:
@@ -71,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)
@@ -188,6 +191,18 @@ class EdidDecodePackage(DistroPackage):
         )
 
 
+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"""
 
@@ -261,7 +276,19 @@ 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(
@@ -271,7 +298,12 @@ class Installer(AmdTool):
                 )
             except FileNotFoundError:
                 edid = False
-            if not edid:
+            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

amd_debug/prerequisites.py

@@ -26,6 +26,7 @@ from amd_debug.common import (
     apply_prefix_wrapper,
     BIT,
     clear_temporary_message,
+    find_ip_version,
     get_distro,
     get_pretty_distro,
     get_property_pyudev,
@@ -48,6 +49,7 @@ from amd_debug.failures import (
     DevSlpDiskIssue,
     DevSlpHostIssue,
     DMArNotEnabled,
+    DmcubTooOld,
     DmiNotSetup,
     FadtWrong,
     I2CHidBug,
@@ -134,20 +136,24 @@ class PrerequisiteValidator(AmdTool):
             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))
+            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):
@@ -395,6 +401,53 @@ class PrerequisiteValidator(AmdTool):
             )
         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 = []
@@ -698,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()
@@ -949,6 +1006,8 @@ class PrerequisiteValidator(AmdTool):
                         stderr=subprocess.DEVNULL,
                     )
                     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}", "👀"
@@ -1099,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(
@@ -1205,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

@@ -9,6 +9,7 @@ import sqlite3
 
 from datetime import date, timedelta, datetime
 from amd_debug.common import (
+    convert_string_to_bool,
     colorize_choices,
     is_root,
     relaunch_sudo,
@@ -32,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:
@@ -47,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:
@@ -85,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
@@ -114,7 +117,16 @@ def prompt_report_arguments(since, until, fname, fmt) -> str:
             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:
@@ -157,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:
@@ -209,8 +223,8 @@ def run_test_cycle(
         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")
@@ -229,7 +243,7 @@ def run_test_cycle(
             fname=fname,
             fmt=fmt,
             tool_debug=debug,
-            report_debug=True,
+            report_debug=report_debug,
         )
         app.run()
 
@@ -347,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)",
     )
 

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.1.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.1
+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.
 

{amd_debug_tools-0.2.1.dist-info → amd_debug_tools-0.2.2.dist-info}/RECORD

@@ -2,44 +2,44 @@ launcher.py,sha256=_Gs0W8tUB2wkTy5Nz4qEzG0VqQcnO7xuIQj0GwV_KbY,968
 test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
 test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
 test_bios.py,sha256=GBAXE_rXd2G-JE0XJ8AvYcF9Me6LTyQQQ8h0Ib3cpxQ,8981
-test_common.py,sha256=VBPRNLt3y-oSVXC-1HGbZF7jHA_6msW-9MMmbMjNrew,11713
+test_common.py,sha256=fb16Oilh5ga6VgF-UgBj6azoYzZnPrS7KpECQ3nCwlg,16335
 test_database.py,sha256=q5ZjI5u20f7ki6iCY5o1iPi0YOvPz1_W0LTDraU8mN4,10040
 test_display.py,sha256=hHggv-zBthF1BlwWWSjzAm7BBw1DWcElwil5xAuz87g,5822
 test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
-test_installer.py,sha256=LqTAjcRIc7DkdHBYBMsRsbDeVtIh_2oEVhETCb_B0cY,10183
+test_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
 test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
 test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
-test_prerequisites.py,sha256=owO-tMgq_3W4Rm85TgdOFGOabKk9OrUUbRHXD0NHiPg,77018
+test_prerequisites.py,sha256=4Ltxx7vGU91b9MX1AtdPLS8iyWJBCNuEKCuO0nnEb_g,83381
 test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
-test_s2idle.py,sha256=VT5iNNVxaL6JdupYPHTIsIVWLBgHRHGTPyXFMO_k1w0,31312
+test_s2idle.py,sha256=-S3yymjprf3_LIgaPGWgzN9FmnyQG55dNc4xqWAF8Z8,32344
 test_sleep_report.py,sha256=R3cUPPT9r9q4q93xk6NFvi4ySgT5laqidk2SASuTWIo,5878
-test_validator.py,sha256=0dwpWFMHHG16vYo6ON_bUa5Av2NTVEJML93oAZZgcH8,30505
+test_validator.py,sha256=NeiX8kT5DiHiiB5lRSJkjIpV32UzaIrW5ljKLmFtBMk,30490
 test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
 amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
 amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
 amd_debug/battery.py,sha256=WN-6ys9PHCZIwg7PdwyBOa62GjBp8WKG0v1YZt5_W5s,3122
 amd_debug/bios.py,sha256=wmPKDsTZeQqsHjWpv-YHdgRNlCtFdzHQ6jJf0H3hjN8,3971
-amd_debug/common.py,sha256=QP3UnOrMFO7NGBgi2CGUvBmtYIalm_Z9xxlvcpze_uQ,9613
+amd_debug/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
 amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
 amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
-amd_debug/failures.py,sha256=QV3wxl9NYxUV5e0VmMy-pNLg4PoLeCVy0RvBux1pnZM,22536
-amd_debug/installer.py,sha256=2upWqR3e9flu-KruDXkoqCu-P4e3R7aVpMQ6dRRurTU,13064
+amd_debug/failures.py,sha256=Otv3YDu7Je4ljSifVmvjObGoOY4OvLIY20pw-v4Dqkw,22911
+amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
 amd_debug/kernel.py,sha256=xzAy-sDY5-sd4jxyU7EaBokS7YsvEjoWRuexaTJNRBc,11851
-amd_debug/prerequisites.py,sha256=szi1YT-iY4F3EoG7gRcN9kVTV4XsjDDMTjLfN7vkhJ4,47685
+amd_debug/prerequisites.py,sha256=bKJA9ztyapB8rxrNEgc-hxazw5Uh-sP5X0S7zplGA0c,50413
 amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
 amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
-amd_debug/s2idle.py,sha256=QAQ1EIhD823_dBsAmSqZuuGTF--bIz2CK2xA13PgJ8c,12695
-amd_debug/sleep_report.py,sha256=dRoE21nkPMFoa5L9i5XrzPug4KesLfAf1RpPFB7Xpt0,15555
-amd_debug/validator.py,sha256=VomxJOp6ZYBp3oYEaNsD-rvio_b346VSRz7-hyhCS_c,33234
+amd_debug/s2idle.py,sha256=lzxLYZBcQllyqEMZfxYEUvQO3ArgVzwL5FHymzvZvSs,13281
+amd_debug/sleep_report.py,sha256=zgwcmSk7S8GAmPtPZJGP29Mr5bcWUBxwNL8HBubKs6Q,15516
+amd_debug/validator.py,sha256=fgG3D0k6DS9ArgzK1SuPUds1FNGoKf2asPUwWoyCsXE,33205
 amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
 amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
 amd_debug/templates/html,sha256=tnpqHDZF5FfhC6YNRUfOG6Vn9ZtISFr10kEXSB476Mw,14518
-amd_debug/templates/md,sha256=F0xt7m-lOsSz1VeucHA6a-1gsOH7rrik15biXnDgd54,904
+amd_debug/templates/md,sha256=r8X2aehnH2gzj0WHYTZ5K9wAqC5y39i_3nkDORSC0uM,787
 amd_debug/templates/stdout,sha256=hyoOJ96K2dJfnWRWhyCuariLKbEHXvs9mstV_g5aMdI,469
 amd_debug/templates/txt,sha256=nNdsvbPFOhGdL7VA-_4k5aN3nB-6ouGQt6AsWst7T3w,649
-amd_debug_tools-0.2.1.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
-amd_debug_tools-0.2.1.dist-info/METADATA,sha256=mNzq0JUgGUeSwdF_H6BRgFb_dNFMvKgu-Htu381x0tE,6783
-amd_debug_tools-0.2.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-amd_debug_tools-0.2.1.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
-amd_debug_tools-0.2.1.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
-amd_debug_tools-0.2.1.dist-info/RECORD,,
+amd_debug_tools-0.2.2.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.2.dist-info/METADATA,sha256=oZ5H5dL216bbAqtOF8VmvtqkqctPIf5iPibPCjjc1tQ,6877
+amd_debug_tools-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.2.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.2.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.2.dist-info/RECORD,,

{amd_debug_tools-0.2.1.dist-info → amd_debug_tools-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

test_common.py

@@ -16,9 +16,11 @@ from platform import uname_result
 from amd_debug.common import (
     apply_prefix_wrapper,
     Colors,
+    convert_string_to_bool,
     colorize_choices,
     check_lockdown,
     compare_file,
+    find_ip_version,
     fatal_error,
     get_distro,
     get_log_priority,
@@ -330,3 +332,113 @@ class TestCommon(unittest.TestCase):
         default = "option1"
         expected_output = f"{Colors.OK}{default}{Colors.ENDC}"
         self.assertEqual(colorize_choices(choices, default), expected_output)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_found(self, mock_exists, mock_read_file):
+        """Test find_ip_version returns True when expected value is found"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+
+        # Simulate file exists and value matches
+        def exists_side_effect(path):
+            return True
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.return_value = "42"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertTrue(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_missing_file(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if file does not exist"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file does not exist
+        mock_exists.return_value = False
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_not_called()
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_not_found_due_to_value_mismatch(
+        self, mock_exists, mock_read_file
+    ):
+        """Test find_ip_version returns False if value does not match"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42}
+        # Simulate file exists but value does not match
+        mock_exists.return_value = True
+        mock_read_file.return_value = "99"
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+        b = os.path.join(base_path, "ip_discovery", "die", "0", kind, "0")
+        expected_path = os.path.join(b, "baz")
+        mock_exists.assert_any_call(expected_path)
+        mock_read_file.assert_any_call(expected_path)
+
+    @patch("amd_debug.common.read_file")
+    @patch("os.path.exists")
+    def test_find_ip_version_multiple_keys(self, mock_exists, mock_read_file):
+        """Test find_ip_version with multiple keys in hw_ver"""
+        base_path = "/foo"
+        kind = "bar"
+        hw_ver = {"baz": 42, "qux": 99}
+
+        # First key: file exists, value does not match
+        # Second key: file exists, value matches
+        def exists_side_effect(path):
+            return True
+
+        def read_file_side_effect(path):
+            if path.endswith("baz"):
+                return "0"
+            if path.endswith("qux"):
+                return "99"
+            return "0"
+
+        mock_exists.side_effect = exists_side_effect
+        mock_read_file.side_effect = read_file_side_effect
+        result = find_ip_version(base_path, kind, hw_ver)
+        self.assertFalse(result)
+
+    def test_convert_string_to_bool_true_values(self):
+        """Test convert_string_to_bool returns True for truthy string values"""
+        self.assertTrue(convert_string_to_bool("True"))
+        self.assertTrue(convert_string_to_bool("1"))
+        self.assertTrue(convert_string_to_bool("'nonempty'"))
+        self.assertTrue(convert_string_to_bool('"nonempty"'))
+
+    def test_convert_string_to_bool_false_values(self):
+        """Test convert_string_to_bool returns False for falsy string values"""
+        self.assertFalse(convert_string_to_bool("False"))
+        self.assertFalse(convert_string_to_bool("0"))
+        self.assertFalse(convert_string_to_bool("''"))
+        self.assertFalse(convert_string_to_bool('""'))
+        self.assertFalse(convert_string_to_bool("None"))
+
+    def test_convert_string_to_bool_invalid_syntax(self):
+        """Test convert_string_to_bool exits on invalid syntax"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("not_a_bool")
+            mock_exit.assert_called_once_with("Invalid entry: not_a_bool")
+
+    def test_convert_string_to_bool_invalid_value(self):
+        """Test convert_string_to_bool exits on invalid value"""
+        with patch("sys.exit") as mock_exit:
+            convert_string_to_bool("[unclosed_list")
+            mock_exit.assert_called_once_with("Invalid entry: [unclosed_list")

test_installer.py

@@ -192,7 +192,7 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function"""
         self.installer.set_requirements("iasl", "ethtool")
         ret = self.installer.install_dependencies()
-        self.assertFalse(ret)
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("amd_debug.installer.get_distro", return_value="ubuntu")
@@ -205,7 +205,9 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on Ubuntu"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        _mock_check_call.assert_called_once_with(["apt", "install", "edid-decode"])
+        _mock_check_call.assert_called_once_with(
+            ["apt", "install", "libdisplay-info-bin"]
+        )
         self.assertTrue(ret)
 
     @patch("builtins.print")
@@ -229,7 +231,7 @@ class TestInstaller(unittest.TestCase):
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
         _mock_check_call.assert_called_once_with(
-            ["dnf", "install", "-y", "edid-decode"]
+            ["dnf", "install", "-y", "libdisplay-info"]
         )
         self.assertTrue(ret)
 
@@ -249,8 +251,8 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on Arch"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        _mock_check_call.assert_not_called()  # edid-decode is not supported on Arch
-        self.assertFalse(ret)
+        _mock_check_call.assert_called_once_with(["pacman", "-Sy", "libdisplay-info"])
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("os.path.exists", return_value=False)
@@ -263,7 +265,7 @@ class TestInstaller(unittest.TestCase):
         """Test install requirements function for edid-decode on unsupported distro"""
         self.installer.set_requirements("edid-decode")
         ret = self.installer.install_dependencies()
-        self.assertFalse(ret)
+        self.assertTrue(ret)
 
     @patch("builtins.print")
     @patch("os.path.exists", return_value=False)

test_prerequisites.py

@@ -8,7 +8,7 @@ This module contains unit tests for the prerequisite functions in the amd-debug-
 import logging
 import unittest
 import subprocess
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch, MagicMock, mock_open
 
 from amd_debug.prerequisites import PrerequisiteValidator
 from amd_debug.failures import *
@@ -180,20 +180,22 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with("IOMMU disabled", "✅")
 
-    def test_check_iommu_no_dma_protection(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 45,
+    )
+    def test_check_iommu_no_dma_protection(self, _mock_open):
         """Test check_iommu when DMA protection is not enabled"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [],
             [],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="0"):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, DMArNotEnabled) for f in self.validator.failures)
@@ -202,20 +204,22 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
         )
 
-    def test_check_iommu_missing_acpi_device(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    def test_check_iommu_missing_acpi_device(self, _mock_open):
         """Test check_iommu when MSFT0201 ACPI device is missing"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [],
             [],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, MissingIommuACPI) for f in self.validator.failures)
@@ -224,47 +228,48 @@ class TestPrerequisiteValidator(unittest.TestCase):
             "IOMMU is misconfigured: missing MSFT0201 ACPI device", "❌"
         )
 
-    def test_check_iommu_missing_policy(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    def test_check_iommu_missing_policy(self, _mock_open):
         """Test check_iommu when policy is not bound to MSFT0201"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
         platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [acpi_device],
             [platform_device],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"), patch(
-            "os.path.exists", return_value=False
-        ):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertFalse(result)
         self.assertTrue(
             any(isinstance(f, MissingIommuPolicy) for f in self.validator.failures)
         )
 
-    def test_check_iommu_properly_configured(self):
+    @patch(
+        "amd_debug.prerequisites.open",
+        new_callable=unittest.mock.mock_open,
+        read_data=b"\x00" * 36 + b"\xff" * 4,
+    )
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    def test_check_iommu_properly_configured(self, _mock_open, _mock_exists):
         """Test check_iommu when IOMMU is properly configured"""
         self.validator.cpu_family = 0x1A
         self.validator.cpu_model = 0x20
         iommu_device = MagicMock(sys_path="/sys/devices/iommu")
-        thunderbolt_device = MagicMock(sys_path="/sys/devices/thunderbolt")
         acpi_device = MagicMock(sys_path="/sys/devices/acpi/MSFT0201")
         platform_device = MagicMock(sys_path="/sys/devices/platform/MSFT0201")
         self.mock_pyudev.list_devices.side_effect = [
             [iommu_device],
-            [thunderbolt_device],
             [acpi_device],
             [platform_device],
         ]
-        with patch("amd_debug.prerequisites.read_file", return_value="1"), patch(
-            "os.path.exists", return_value=True
-        ):
-            result = self.validator.check_iommu()
+        result = self.validator.check_iommu()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with("IOMMU properly configured", "✅")
 
@@ -1737,7 +1742,7 @@ class TestPrerequisiteValidator(unittest.TestCase):
         result = self.validator.capture_edid()
         self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with(
-            "edid-decode not installed, unable to decode EDID", "👀"
+            "Failed to capture EDID table", "👀"
         )
 
     @patch("amd_debug.prerequisites.subprocess.check_output")
@@ -1750,9 +1755,9 @@ class TestPrerequisiteValidator(unittest.TestCase):
             returncode=1, cmd="edid-decode", output=b"Error decoding EDID"
         )
         result = self.validator.capture_edid()
-        self.assertFalse(result)
+        self.assertTrue(result)
         self.mock_db.record_prereq.assert_called_with(
-            "Failed to capture EDID table: b'Error decoding EDID'", "👀"
+            "Failed to capture EDID table", "👀"
         )
 
     @patch("amd_debug.prerequisites.subprocess.check_output")
@@ -1767,3 +1772,164 @@ class TestPrerequisiteValidator(unittest.TestCase):
         self.mock_db.record_debug.assert_called_with(
             apply_prefix_wrapper("EDID for Monitor1:", "Decoded EDID data")
         )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists")
+    @patch("amd_debug.prerequisites.read_file")
+    def test_check_dpia_pg_dmcub_usb4_found(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when USB4 routers are found"""
+        usb4_device = MagicMock()
+        self.mock_pyudev.list_devices.side_effect = [
+            [usb4_device],  # First call: USB4 present
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_debug.assert_called_with(
+            "USB4 routers found, no need to check DMCUB version"
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    @patch("amd_debug.prerequisites.read_file", return_value="0x90001B01")
+    def test_check_dpia_pg_dmcub_dmcub_fw_version_new_enough(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB firmware version is new enough"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0000:01:00.0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        with patch("builtins.open", new_callable=mock_open, read_data="3") as mock_file:
+            handlers = (
+                mock_file.return_value,
+                mock_open(read_data="5").return_value,
+                mock_open(read_data="0").return_value,
+            )
+            mock_open.side_effect = handlers
+            result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=True)
+    @patch("amd_debug.prerequisites.read_file", return_value="0x8001B00")
+    def test_check_dpia_pg_dmcub_dmcub_fw_version_too_old(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB firmware version is too old"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0000:01:00.0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "DMCUB Firmware is outdated", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, DmcubTooOld) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
+    @patch(
+        "amd_debug.prerequisites.read_file",
+        side_effect=[
+            "",  # sysfs read returns empty, so fallback to debugfs
+            "DMCUB fw: 09001B00\nOther line\n",  # debugfs read
+        ],
+    )
+    def test_check_dpia_pg_dmcub_debugfs_version_new_enough(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB version is found in debugfs and is new enough"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=True)
+    @patch("amd_debug.prerequisites.os.path.exists", return_value=False)
+    @patch(
+        "amd_debug.prerequisites.read_file",
+        side_effect=[
+            "DMCUB fw: 0x08001B00\nOther line\n",  # debugfs read
+        ],
+    )
+    def test_check_dpia_pg_dmcub_debugfs_version_too_old(
+        self, mock_read_file, mock_path_exists, mock_find_ip_version
+    ):
+        """Test check_dpia_pg_dmcub when DMCUB version is found in debugfs and is too old"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertFalse(result)
+        self.mock_db.record_prereq.assert_called_with(
+            "DMCUB Firmware is outdated", "❌"
+        )
+        self.assertTrue(
+            any(isinstance(f, DmcubTooOld) for f in self.validator.failures)
+        )
+
+    @patch("amd_debug.prerequisites.find_ip_version", return_value=False)
+    def test_check_dpia_pg_dmcub_no_matching_dcn(self, mock_find_ip_version):
+        """Test check_dpia_pg_dmcub when no matching DCN is found"""
+        self.mock_pyudev.list_devices.side_effect = [
+            [],  # First call: no USB4
+            [
+                MagicMock(
+                    properties={
+                        "PCI_CLASS": "30000",
+                        "PCI_ID": "1002abcd",
+                        "PCI_SLOT_NAME": "0",
+                    },
+                    sys_path="/sys/devices/pci0000:01/0000:01:00.0",
+                )
+            ],
+        ]
+        result = self.validator.check_dpia_pg_dmcub()
+        self.assertTrue(result)
+        self.mock_db.record_prereq.assert_not_called()

test_s2idle.py

@@ -381,6 +381,7 @@ class TestTestFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         mock_sleep_validator_instance = mock_sleep_validator.return_value
@@ -605,6 +606,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
         mock_sleep_report_instance = mock_sleep_report.return_value
 
@@ -614,10 +616,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -640,10 +644,12 @@ class TestReportFunction(unittest.TestCase):
                 fname=None,
                 fmt=None,
                 tool_debug=True,
-                report_debug=True,
+                report_debug=None,
             )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
 
     @patch("amd_debug.s2idle.prompt_report_arguments")
     @patch(
@@ -659,6 +665,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         result = report(
@@ -667,10 +674,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -695,6 +704,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
 
         result = report(
@@ -703,10 +713,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -729,6 +741,7 @@ class TestReportFunction(unittest.TestCase):
             "2023-02-01",
             "report.html",
             "html",
+            True,
         )
         mock_sleep_report_instance = mock_sleep_report.return_value
         mock_sleep_report_instance.run.side_effect = ValueError("Invalid value")
@@ -739,10 +752,12 @@ class TestReportFunction(unittest.TestCase):
             fname=None,
             fmt=None,
             tool_debug=True,
-            report_debug=True,
+            report_debug=None,
         )
 
-        mock_prompt_report_arguments.assert_called_once_with(None, None, None, None)
+        mock_prompt_report_arguments.assert_called_once_with(
+            None, None, None, None, None
+        )
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
             until="2023-02-01",
@@ -758,14 +773,14 @@ class TestReportFunction(unittest.TestCase):
 class TestPromptReportArguments(unittest.TestCase):
     """Test prompt_report_arguments function"""
 
-    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "html"])
+    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "html", "true"])
     @patch("amd_debug.s2idle.get_report_file", return_value="report.html")
     @patch("amd_debug.s2idle.get_report_format", return_value="html")
     def test_prompt_report_arguments_success(
         self, mock_get_report_format, mock_get_report_file, _mock_input
     ):
         """Test prompt_report_arguments with valid inputs"""
-        result = prompt_report_arguments(None, None, None, None)
+        result = prompt_report_arguments(None, None, None, None, None)
         self.assertEqual(result[0], datetime(2023, 1, 1))
         self.assertEqual(result[1], datetime(2023, 2, 1))
         self.assertEqual(result[2], "report.html")
@@ -775,33 +790,36 @@ class TestPromptReportArguments(unittest.TestCase):
 
     @patch(
         "builtins.input",
-        side_effect=["invalid-date", "2023-01-01", "2023-02-01", "html"],
+        side_effect=["invalid-date", "2023-01-01", "2023-02-01", "html", "true"],
     )
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_since_date(self, mock_exit, mock_input):
         """Test prompt_report_arguments with invalid 'since' date"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with(
             "Invalid date, use YYYY-MM-DD: Invalid isoformat string: 'invalid-date'"
         )
 
     @patch(
         "builtins.input",
-        side_effect=["2023-01-01", "invalid-date", "2023-02-01", "html"],
+        side_effect=["2023-01-01", "invalid-date", "2023-02-01", "html", "true"],
     )
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_until_date(self, mock_exit, mock_input):
         """Test prompt_report_arguments with invalid 'until' date"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with(
             "Invalid date, use YYYY-MM-DD: Invalid isoformat string: 'invalid-date'"
         )
 
-    @patch("builtins.input", side_effect=["2023-01-01", "2023-02-01", "invalid-format"])
+    @patch(
+        "builtins.input",
+        side_effect=["2023-01-01", "2023-02-01", "invalid-format", "true"],
+    )
     @patch("amd_debug.s2idle.get_report_format", return_value="html")
     @patch("sys.exit")
     def test_prompt_report_arguments_invalid_format(
@@ -810,11 +828,27 @@ class TestPromptReportArguments(unittest.TestCase):
         """Test prompt_report_arguments with invalid format"""
         mock_exit.side_effect = SystemExit
         with self.assertRaises(SystemExit):
-            prompt_report_arguments(None, None, None, None)
+            prompt_report_arguments(None, None, None, None, None)
         mock_exit.assert_called_once_with("Invalid format: invalid-format")
         mock_get_report_format.assert_called_once()
 
-    @patch("builtins.input", side_effect=["", "", ""])
+    @patch(
+        "builtins.input",
+        side_effect=["2023-01-01", "2023-02-01", "html", "foo_the_bar"],
+    )
+    @patch("amd_debug.s2idle.get_report_format", return_value="html")
+    @patch("sys.exit")
+    def test_prompt_report_arguments_invalid_report(
+        self, mock_exit, mock_get_report_format, mock_input
+    ):
+        """Test prompt_report_arguments with invalid format"""
+        mock_exit.side_effect = SystemExit
+        with self.assertRaises(SystemExit):
+            prompt_report_arguments(None, None, None, None, None)
+        mock_exit.assert_called_once_with("Invalid entry: Foo_the_bar")
+        mock_get_report_format.assert_called_once()
+
+    @patch("builtins.input", side_effect=["", "", "", ""])
     @patch(
         "amd_debug.s2idle.get_report_file",
         return_value="amd-s2idle-report-2023-01-01.html",
@@ -824,10 +858,11 @@ class TestPromptReportArguments(unittest.TestCase):
         self, mock_get_report_format, mock_get_report_file, mock_input
     ):
         """Test prompt_report_arguments with default values"""
-        result = prompt_report_arguments(None, None, None, None)
+        result = prompt_report_arguments(None, None, None, None, None)
         self.assertEqual(datetime.date(result[0]), Defaults.since)
         self.assertEqual(datetime.date(result[1]), Defaults.until)
         self.assertEqual(result[2], "amd-s2idle-report-2023-01-01.html")
         self.assertEqual(result[3], "html")
+        self.assertEqual(result[4], True)
         mock_get_report_file.assert_called_once_with(None, "html")
         mock_get_report_format.assert_called()

test_validator.py

@@ -321,13 +321,11 @@ class TestValidator(unittest.TestCase):
         self.validator.lockdown = False
         with patch("os.path.exists", return_value=False), patch(
             "amd_debug.validator.read_file", side_effect=FileNotFoundError
-        ), patch.object(
-            self.validator.db, "record_cycle_data"
-        ) as mock_record_cycle_data:
+        ), patch.object(self.validator.db, "record_debug") as mock_record:
             result = self.validator.capture_hw_sleep()
             self.assertFalse(result)
-            mock_record_cycle_data.assert_called_once_with(
-                "HW sleep statistics file missing", "❌"
+            mock_record.assert_called_once_with(
+                "HW sleep statistics file /sys/kernel/debug/amd_pmc/smu_fw_info is missing"
             )
 
     def test_capture_amdgpu_ips_status(self):