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

amd_debug/prerequisites.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
 """
@@ -21,7 +20,7 @@ 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.kernel import get_kernel_log, SystemdLogger, CySystemdLogger, DmesgLogger
 from amd_debug.common import (
     apply_prefix_wrapper,
     BIT,
@@ -55,12 +54,15 @@ from amd_debug.failures import (
     I2CHidBug,
     KernelRingBufferWrapped,
     LimitedCores,
+    MissingAmdCaptureModule,
     MissingAmdgpu,
     MissingAmdgpuFirmware,
     MissingAmdPmc,
+    MissingGpu,
     MissingDriver,
     MissingIommuACPI,
     MissingIommuPolicy,
+    MissingIsp4PlatformDriver,
     MissingThunderbolt,
     MissingXhciHcd,
     MSRFailure,
@@ -128,36 +130,56 @@ class PrerequisiteValidator(AmdTool):
         if not self.db.get_last_prereq_ts():
             self.run()
 
+    def capture_nvidia(self):
+        """Capture the NVIDIA GPU state"""
+        p = os.path.join("/", "proc", "driver", "nvidia", "version")
+        if not os.path.exists(p):
+            return True
+        try:
+            self.db.record_debug_file(p)
+        except PermissionError:
+            self.db.record_prereq("NVIDIA GPU version not readable", "👀")
+            return True
+        p = os.path.join("/", "proc", "driver", "nvidia", "gpus")
+        if not os.path.exists(p):
+            return True
+        for root, _dirs, files in os.walk(p, topdown=False):
+            for f in files:
+                try:
+                    self.db.record_debug(f"NVIDIA {f}")
+                    self.db.record_debug_file(os.path.join(root, f))
+                except PermissionError:
+                    self.db.record_prereq("NVIDIA GPU {f} not readable", "👀")
+        return True
+
     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():
+        for p in edids:
             output = None
-            for cmd in ["di-edid-decode", "edid-decode"]:
+            for tool in ["di-edid-decode", "edid-decode"]:
                 try:
-                    cmd = ["edid-decode", p]
+                    cmd = [tool, p]
                     output = subprocess.check_output(
                         cmd, stderr=subprocess.DEVNULL
-                    ).decode("utf-8")
+                    ).decode("utf-8", errors="ignore")
                     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}"
-                    )
+                except subprocess.CalledProcessError as _e:
+                    pass
             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))
+                self.db.record_debug(apply_prefix_wrapper(f"EDID for {p}:", output))
         return True
 
     def check_amdgpu(self):
         """Check for the AMDGPU driver"""
+        count = 0
         for device in self.pyudev.list_devices(subsystem="pci"):
             klass = device.properties.get("PCI_CLASS")
             if klass not in ["30000", "38000"]:
@@ -165,6 +187,7 @@ class PrerequisiteValidator(AmdTool):
             pci_id = device.properties.get("PCI_ID")
             if not pci_id.startswith("1002"):
                 continue
+            count += 1
             if device.properties.get("DRIVER") != "amdgpu":
                 self.db.record_prereq("GPU driver `amdgpu` not loaded", "❌")
                 self.failures += [MissingAmdgpu()]
@@ -172,6 +195,10 @@ class PrerequisiteValidator(AmdTool):
             slot = device.properties.get("PCI_SLOT_NAME")
 
             self.db.record_prereq(f"GPU driver `amdgpu` bound to {slot}", "✅")
+        if count == 0:
+            self.db.record_prereq("Integrated GPU not found", "❌")
+            self.failures += [MissingGpu()]
+            return False
         return True
 
     def check_amdgpu_parameters(self):
@@ -245,7 +272,6 @@ class PrerequisiteValidator(AmdTool):
         for dev in self.pyudev.list_devices(subsystem="pci", DRIVER="nvme"):
             # https://git.kernel.org/torvalds/c/e79a10652bbd3
             if minimum_kernel(6, 10):
-                self.db.record_debug("New enough kernel to avoid NVME check")
                 break
             pci_slot_name = dev.properties["PCI_SLOT_NAME"]
             vendor = dev.properties.get("ID_VENDOR_FROM_DATABASE", "")
@@ -319,7 +345,6 @@ class PrerequisiteValidator(AmdTool):
         # not needed to check in newer kernels
         # see https://github.com/torvalds/linux/commit/77f1972bdcf7513293e8bbe376b9fe837310ee9c
         if minimum_kernel(6, 10):
-            self.db.record_debug("New enough kernel to avoid HSMP check")
             return True
         f = os.path.join("/", "boot", f"config-{platform.uname().release}")
         if os.path.exists(f):
@@ -527,7 +552,7 @@ class PrerequisiteValidator(AmdTool):
                 f"{keys['sys_vendor']} {keys['product_name']} ({keys['product_family']})",
                 "💻",
             )
-            debug_str = "DMI data:\n"
+            debug_str = "DMI|value\n"
             for key, value in keys.items():
                 if (
                     "product_name" in key
@@ -535,7 +560,7 @@ class PrerequisiteValidator(AmdTool):
                     or "product_family" in key
                 ):
                     continue
-                debug_str += f"{key}: {value}\n"
+                debug_str += f"{key}| {value}\n"
             self.db.record_debug(debug_str)
         return True
 
@@ -600,6 +625,9 @@ class PrerequisiteValidator(AmdTool):
                 with open(target, "rb") as r:
                     r.seek(0x70)
                     found = struct.unpack("<I", r.read(4))[0] & BIT(21)
+            except FileNotFoundError:
+                self.db.record_prereq("FADT check unavailable", "🚦")
+                return True
             except PermissionError:
                 self.db.record_prereq("FADT check unavailable", "🚦")
                 return True
@@ -652,7 +680,9 @@ class PrerequisiteValidator(AmdTool):
         """Check the source for kernel logs"""
         if isinstance(self.kernel_log, SystemdLogger):
             self.db.record_prereq("Logs are provided via systemd", "✅")
-        if isinstance(self.kernel_log, DmesgLogger):
+        elif isinstance(self.kernel_log, CySystemdLogger):
+            self.db.record_prereq("Logs are provided via cysystemd", "✅")
+        elif isinstance(self.kernel_log, DmesgLogger):
             self.db.record_prereq(
                 "Logs are provided via dmesg, timestamps may not be accurate over multiple cycles",
                 "🚦",
@@ -720,6 +750,9 @@ class PrerequisiteValidator(AmdTool):
             p = os.path.join("/", "sys", "kernel", "debug", "gpio")
             try:
                 contents = read_file(p)
+            except FileNotFoundError:
+                self.db.record_prereq("GPIO debugfs not available", "👀")
+                contents = None
             except PermissionError:
                 self.db.record_debug(f"Unable to capture {p}")
                 contents = None
@@ -756,7 +789,7 @@ class PrerequisiteValidator(AmdTool):
                     "utf-8"
                 )
             except FileNotFoundError:
-                self.db.record_prereq(f"ethtool is missing", "👀")
+                self.db.record_prereq("ethtool is missing", "👀")
                 return True
             for line in output.split("\n"):
                 if "Supports Wake-on" in line:
@@ -916,7 +949,7 @@ class PrerequisiteValidator(AmdTool):
         devices = []
         for dev in self.pyudev.list_devices(subsystem="pci"):
             devices.append(dev)
-        debug_str = "PCI devices\n"
+        debug_str = "PCI Slot | Vendor | Class | ID | ACPI path\n"
         for dev in devices:
             pci_id = dev.properties["PCI_ID"].lower()
             pci_slot_name = dev.properties["PCI_SLOT_NAME"]
@@ -939,18 +972,53 @@ class PrerequisiteValidator(AmdTool):
             p = os.path.join(dev.sys_path, "firmware_node", "path")
             if os.path.exists(p):
                 acpi = read_file(p)
-                debug_str += (
-                    f"{prefix}{pci_slot_name} : "
-                    f"{database_vendor} {database_class} [{pci_id}] : {acpi}\n"
-                )
             else:
-                debug_str += (
-                    f"{prefix}{pci_slot_name} : "
-                    f"{database_vendor} {database_class} [{pci_id}]\n"
-                )
+                acpi = ""
+            debug_str += (
+                f"{prefix}{pci_slot_name} | "
+                f"{database_vendor} | {database_class} | {pci_id} | {acpi}\n"
+            )
         if debug_str:
             self.db.record_debug(debug_str)
 
+    def check_isp4(self):
+        """Check if camera supported by ISP is present and set up properly"""
+        devices = []
+        for dev in self.pyudev.list_devices(subsystem="acpi"):
+            # look for ACPI device for camera (OMNI5C10:00 is seen today)
+            if not dev.sys_name.startswith("OMNI5C10"):
+                continue
+            p = os.path.join(dev.sys_path, "path")
+            if not os.path.exists(p):
+                continue
+            devices.append(dev)
+        for dev in devices:
+            p = os.path.join(dev.sys_path, "physical_node", "driver")
+            if os.path.exists(p):
+                driver = os.path.basename(os.readlink(p))
+            else:
+                driver = None
+            if driver != "amd-isp4":
+                self.db.record_prereq(
+                    f"ISP4 platform camera driver 'amd-isp4' not bound to {dev.sys_name}",
+                    "❌",
+                )
+                self.failures += [MissingIsp4PlatformDriver()]
+                return False
+            self.db.record_prereq(
+                f"ISP4 platform camera driver 'amd-isp4' bound to {dev.sys_name}", "✅"
+            )
+            # check if `amd_capture` module is loaded
+            p = os.path.join("/", "sys", "module", "amd_capture")
+            if not os.path.exists(p):
+                self.db.record_prereq(
+                    "Camera driver module 'amd_capture' not loaded", "❌"
+                )
+                self.failures += [MissingAmdCaptureModule()]
+                return False
+            self.db.record_prereq("Camera driver module 'amd_capture' loaded", "✅")
+        return True
+
     def map_acpi_path(self):
         """Map of ACPI devices to ACPI paths"""
         devices = []
@@ -964,12 +1032,8 @@ class PrerequisiteValidator(AmdTool):
                 if status == 0:
                     continue
             devices.append(dev)
-        debug_str = "ACPI name: ACPI path [driver]\n"
+        debug_str = "ACPI name | ACPI path | Kernel driver\n"
         for dev in devices:
-            if dev == devices[-1]:
-                prefix = "└─"
-            else:
-                prefix = "│ "
             p = os.path.join(dev.sys_path, "path")
             pth = read_file(p)
             p = os.path.join(dev.sys_path, "physical_node", "driver")
@@ -977,7 +1041,7 @@ class PrerequisiteValidator(AmdTool):
                 driver = os.path.basename(os.readlink(p))
             else:
                 driver = None
-            debug_str += f"{prefix}{dev.sys_name}: {pth} [{driver}]\n"
+            debug_str += f"{dev.sys_name} | {pth} | {driver}\n"
         if debug_str:
             self.db.record_debug(debug_str)
         return True
@@ -1016,6 +1080,21 @@ class PrerequisiteValidator(AmdTool):
                     shutil.rmtree(tmpd)
         return True
 
+    def capture_cstates(self):
+        """Capture ACPI C state information for the first CPU (assumes the same for all CPUs)"""
+        base = os.path.join("/", "sys", "bus", "cpu", "devices", "cpu0", "cpuidle")
+        paths = {}
+        for root, _dirs, files in os.walk(base, topdown=False):
+            for fname in files:
+                target = os.path.join(root, fname)
+                with open(target, "rb") as f:
+                    paths[target] = f.read()
+        debug_str = "ACPI C-state information\n"
+        for path, data in paths.items():
+            prefix = "│ " if path != list(paths.keys())[-1] else "└─"
+            debug_str += f"{prefix}{path}: {data.decode('utf-8', 'ignore')}"
+        self.db.record_debug(debug_str)
+
     def capture_battery(self):
         """Capture battery information"""
         obj = Batteries()
@@ -1074,11 +1153,22 @@ class PrerequisiteValidator(AmdTool):
         # check for artificially limited CPUs
         p = os.path.join("/", "sys", "devices", "system", "cpu", "kernel_max")
         max_cpus = int(read_file(p)) + 1  # 0 indexed
-        # https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/24594.pdf
-        # Extended Topology Enumeration (NumLogCores)
-        # CPUID 0x80000026 subleaf 1
+        # https://docs.amd.com/v/u/en-US/40332-PUB_4.08
+        # E.4.24 Function 8000_0026—Extended CPU Topology
         try:
-            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, 1)
+            # Need to discover the socket level to look at all CCDs in the socket
+            for level in range(0, 5):
+                _, _, ecx, _ = read_cpuid(0, 0x80000026, level)
+                level_type = (ecx >> 8) & 0xFF
+                if level_type == 0:
+                    self.db.record_prereq(
+                        "Unable to discover CPU topology, didn't find socket level",
+                        "🚦",
+                    )
+                    return True
+                if level_type == 4:
+                    break
+            _, cpu_count, _, _ = read_cpuid(0, 0x80000026, level)
             if cpu_count > max_cpus:
                 self.db.record_prereq(
                     f"The kernel has been limited to {max_cpus} CPU cores, "
@@ -1149,32 +1239,17 @@ class PrerequisiteValidator(AmdTool):
         if self.cpu_family == 0x1A and self.cpu_model in affected_1a:
             found_iommu = False
             found_acpi = False
-            found_dmar = False
             for dev in self.pyudev.list_devices(subsystem="iommu"):
                 found_iommu = True
                 debug_str += f"Found IOMMU {dev.sys_path}\n"
                 break
+
+            # User turned off IOMMU, no problems
             if not found_iommu:
                 self.db.record_prereq("IOMMU disabled", "✅")
                 return True
-            debug_str += "DMA protection:\n"
-            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(
-                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
-                )
-                self.failures += [DMArNotEnabled()]
-                return False
+
+            # Look for MSFT0201 in DSDT/SSDT
             for dev in self.pyudev.list_devices(subsystem="acpi"):
                 if "MSFT0201" in dev.sys_path:
                     found_acpi = True
@@ -1184,13 +1259,39 @@ class PrerequisiteValidator(AmdTool):
                 )
                 self.failures += [MissingIommuACPI("MSFT0201")]
                 return False
-            # check that policy is bound to it
+
+            # Check that policy is bound to it
             for dev in self.pyudev.list_devices(subsystem="platform"):
                 if "MSFT0201" in dev.sys_path:
                     p = os.path.join(dev.sys_path, "iommu")
                     if not os.path.exists(p):
                         self.failures += [MissingIommuPolicy("MSFT0201")]
                         return False
+
+            # Check pre-boot DMA
+            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"IVRS: Virtualization info: 0x{virt_info:x}\n"
+            found_ivrs_dmar = (virt_info & 0x2) != 0
+
+            # check for MSFT0201 in IVRS (alternative to pre-boot DMA)
+            target_bytes = "MSFT0201".encode("utf-8")
+            found_ivrs_msft0201 = data.find(target_bytes) != -1
+            debug_str += f"IVRS: Found MSFT0201: {found_ivrs_msft0201}"
+
+            self.db.record_debug(debug_str)
+            if not found_ivrs_dmar and not found_ivrs_msft0201:
+                self.db.record_prereq(
+                    "IOMMU is misconfigured: Pre-boot DMA protection not enabled", "❌"
+                )
+                self.failures += [DMArNotEnabled()]
+                return False
             self.db.record_prereq("IOMMU properly configured", "✅")
         return True
 
@@ -1200,6 +1301,8 @@ class PrerequisiteValidator(AmdTool):
             return True
         if self.cpu_model not in [0x74, 0x78]:
             return True
+        if not self.smu_version:
+            return True
         if version.parse(self.smu_version) > version.parse("76.60.0"):
             return True
         if version.parse(self.smu_version) < version.parse("76.18.0"):
@@ -1222,9 +1325,8 @@ class PrerequisiteValidator(AmdTool):
         # ignore kernel warnings
         taint &= ~BIT(9)
         if taint != 0:
-            self.db.record_prereq(f"Kernel is tainted: {taint}", "❌")
+            self.db.record_prereq(f"Kernel is tainted: {taint}", "🚦")
             self.failures += [TaintedKernel()]
-            return False
         return True
 
     def run(self):
@@ -1239,6 +1341,8 @@ class PrerequisiteValidator(AmdTool):
             self.capture_logind,
             self.capture_pci_acpi,
             self.capture_edid,
+            self.capture_nvidia,
+            self.capture_cstates,
         ]
         checks = []
 
@@ -1268,6 +1372,7 @@ class PrerequisiteValidator(AmdTool):
                 self.check_iommu,
                 self.check_asus_rog_ally,
                 self.check_dpia_pg_dmcub,
+                self.check_isp4,
             ]
 
         checks += [
@@ -1291,7 +1396,7 @@ class PrerequisiteValidator(AmdTool):
             if not check():
                 result = False
         if not result:
-            self.db.record_prereq(Headers.BrokenPrerequisites, "💯")
+            self.db.record_prereq(Headers.BrokenPrerequisites, "🚫")
         self.db.sync()
         clear_temporary_message(len(msg))
         return result
@@ -1310,7 +1415,7 @@ class PrerequisiteValidator(AmdTool):
                     logging.debug(line)
 
         if len(self.failures) == 0:
-            return True
+            return
         print_color(Headers.ExplanationReport, "🗣️")
         for item in self.failures:
             item.get_failure()

amd_debug/pstate.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 """CPPC triage script for AMD systems"""
 
@@ -293,22 +292,26 @@ def parse_args():
         action="store_true",
         help="Enable tool debug logging",
     )
-    subparsers.add_parser("version", help="Show version information")
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
     if len(sys.argv) == 1:
         parser.print_help(sys.stderr)
         sys.exit(1)
     return parser.parse_args()
 
 
-def main():
+def main() -> None | int:
     """Main function"""
     args = parse_args()
     ret = False
-    if args.command == "version":
+    if args.version:
         print(version())
-        return True
+        return
     elif args.command == "triage":
         triage = AmdPstateTriage(args.tool_debug)
         ret = triage.run()
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return

amd_debug/s2idle.py

@@ -1,4 +1,3 @@
-#!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 """s2idle analysis tool"""
 import argparse
@@ -11,6 +10,7 @@ from datetime import date, timedelta, datetime
 from amd_debug.common import (
     convert_string_to_bool,
     colorize_choices,
+    fatal_error,
     is_root,
     relaunch_sudo,
     show_log_info,
@@ -61,21 +61,22 @@ 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)
-        if os.environ.get("XDG_SESSION_TYPE"):
-            subprocess.call(["sudo", "-E", "-u", user, "xdg-open", fname])
-        else:
-            print(
-                "To display report automatically in browser launch tool "
-                f"with '-E' argument (Example: sudo -E {sys.argv[0]})"
-            )
+        cmd = [
+            "systemd-run",
+            "--user",
+            f"--machine={user}@.host",
+            "xdg-open",
+            os.path.abspath(fname),
+        ]
+        ret = subprocess.call(cmd)
+        if ret:
+            fatal_error(f"Failed to open report: {ret}")
 
 
 def get_report_file(report_file, extension) -> str:
     """Prompt user for report file"""
     if extension == "stdout":
-        return None
+        return ""
     if not report_file:
         return f"amd-s2idle-report-{date.today()}.{extension}"
     return report_file
@@ -88,7 +89,7 @@ def get_report_format() -> str:
     return "html"
 
 
-def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
+def prompt_report_arguments(since, until, fname, fmt, report_debug) -> list:
     """Prompt user for report configuration"""
     if not since:
         default = Defaults.since
@@ -120,7 +121,7 @@ def prompt_report_arguments(since, until, fname, fmt, report_debug) -> str:
     if report_debug is None:
         inp = (
             input(
-                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, "true")})? "
+                f"{Headers.ReportDebugDescription} ({colorize_choices(Defaults.boolean_choices, 'true')})? "
             )
             .lower()
             .capitalize()
@@ -211,6 +212,16 @@ def run_test_cycle(
         print("Failed to install dependencies")
         return False
 
+    try:
+        duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
+        total_seconds = (duration + wait) * count
+        until_time = datetime.now() + timedelta(seconds=total_seconds)
+        since, until, fname, fmt, report_debug = prompt_report_arguments(
+            datetime.now().isoformat(), until_time.isoformat(), fname, fmt, True
+        )
+    except KeyboardInterrupt:
+        sys.exit("\nTest cancelled")
+
     try:
         app = PrerequisiteValidator(debug)
         run = app.run()
@@ -221,37 +232,33 @@ def run_test_cycle(
 
     if run or force:
         app = SleepValidator(tool_debug=debug, bios_debug=bios_debug)
-        try:
-            duration, wait, count = prompt_test_arguments(duration, wait, count, rand)
-            since, until, fname, fmt, report_debug = prompt_report_arguments(
-                datetime.now().isoformat(), Defaults.until.isoformat(), fname, fmt, True
-            )
-        except KeyboardInterrupt:
-            sys.exit("\nTest cancelled")
 
-        app.run(
+        run = app.run(
             duration=duration,
             wait=wait,
             count=count,
             rand=rand,
             logind=logind,
         )
+        until = datetime.now()
+    else:
+        since = None
+        until = None
+
+    app = SleepReport(
+        since=since,
+        until=until,
+        fname=fname,
+        fmt=fmt,
+        tool_debug=debug,
+        report_debug=report_debug,
+    )
+    app.run()
 
-        app = SleepReport(
-            since=since,
-            until=until,
-            fname=fname,
-            fmt=fmt,
-            tool_debug=debug,
-            report_debug=report_debug,
-        )
-        app.run()
-
-        # open report in browser if it's html
-        display_report_file(fname, fmt)
+    # open report in browser if it's html
+    display_report_file(fname, fmt)
 
-        return True
-    return False
+    return True
 
 
 def install(debug) -> None:
@@ -308,10 +315,8 @@ 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",
@@ -384,7 +389,9 @@ def parse_args():
             help="Enable tool debug logging",
         )
 
-    subparsers.add_parser("version", help="Show version information")
+    parser.add_argument(
+        "--version", action="store_true", help="Show version information"
+    )
 
     if len(sys.argv) == 1:
         parser.print_help(sys.stderr)
@@ -393,7 +400,7 @@ def parse_args():
     return parser.parse_args()
 
 
-def main():
+def main() -> None | int:
     """Main function"""
     args = parse_args()
     ret = False
@@ -426,10 +433,12 @@ def main():
             args.logind,
             args.bios_debug,
         )
-    elif args.action == "version":
+    elif args.version:
         print(version())
-        return True
+        return
     else:
         sys.exit("no action specified")
     show_log_info()
-    return ret
+    if ret is False:
+        return 1
+    return