Flashing JetPack

# on the x86_64 Ubuntu host, with the jumper in place and the board powered on
lsusb | grep -i nvidia

$ lsusb | grep -i nvidia   # captured on the bench — your bus and device numbers will differ
Bus 001 Device 014: ID 0955:7523 NVIDIA Corp. APX

0955 is NVIDIA's USB vendor identifier and APX is the name the recovery bootloader answers to. The product identifier after the colon varies by module generation, so match on the vendor and the APX label and ignore the rest. An empty result means the board is booting normally, the jumper went on after power, or the cable is a charge-only one. Sorting that out now takes a minute; sorting it out after SDK Manager has sat at "waiting for target" for a quarter of an hour does not.

# labs/jetpack_verify.py
import re
from pathlib import Path

TEGRA_RELEASE = Path("/etc/nv_tegra_release")


def read_text(path: Path) -> str | None:
    """The file's contents, or None if this board has no such file."""
    try:
        return path.read_text().strip()
    except OSError:
        return None


def l4t_version(banner: str) -> str:
    """Turn the release banner into something comparable, like 'R36.4.3'."""
    match = re.search(r"R(\d+) \(release\), REVISION: (\d+\.\d+)", banner)
    if match is None:
        raise ValueError(f"unreadable release banner: {banner[:48]!r}")
    return f"R{match.group(1)}.{match.group(2)}"


if __name__ == "__main__":
    text = read_text(TEGRA_RELEASE)
    print(text)
    print("parsed:", l4t_version(text))

$ uv run python -m labs.jetpack_verify   # on the Jetson, after the flash — your GCID and date will differ
# R36 (release), REVISION: 4.3, GCID: 38968081, BOARD: generic, EABI: aarch64, DATE: Wed Jan  8 01:49:37 UTC 2025
parsed: R36.4.3

Two decisions in eleven lines. read_text catches OSError instead of FileNotFoundError, so a file that exists but cannot be opened (wrong permissions, a directory where a file should be) comes back as a missing value too, and a diagnostic script never dies on the first path it cannot read. The parser, on the other hand, raises when the banner is present but unrecognisable. Those are different situations and they deserve different answers: one is "the installer never wrote this", the other is "the installer wrote something I do not understand", and a report that collapses them into one row will send you looking in the wrong place. L4T R36.4.3 is what this bench's JetPack 6.2.2 media produced; the revision paired with your download is printed on its release page, so copy it from there instead of trusting mine.

# labs/jetpack_verify.py — continued
import platform
from collections.abc import Callable
from dataclasses import dataclass

CUDA_ROOT = Path("/usr/local/cuda")
CUDA_VERSION_TXT = CUDA_ROOT / "version.txt"

EXPECTED = {
    "l4t_release": "R36.4.3",
    "tegra_kernel": "-tegra",
    "cuda_runtime": "12.6",
}


@dataclass
class Check:
    name: str
    expected: str
    detected: str = "not read"
    ok: bool = False


def check_l4t_release() -> Check:
    check = Check("l4t_release", EXPECTED["l4t_release"])
    banner = read_text(TEGRA_RELEASE)
    if banner is None:
        check.detected = f"no file at {TEGRA_RELEASE}"
        return check
    check.detected = l4t_version(banner)
    check.ok = check.detected == check.expected
    return check


def check_tegra_kernel() -> Check:
    check = Check("tegra_kernel", EXPECTED["tegra_kernel"])
    check.detected = platform.release()
    check.ok = check.detected.endswith(EXPECTED["tegra_kernel"])
    return check


def check_cuda_runtime() -> Check:
    check = Check("cuda_runtime", EXPECTED["cuda_runtime"])
    text = read_text(CUDA_VERSION_TXT)
    if text is None:
        check.detected = f"no file at {CUDA_VERSION_TXT}"
        return check
    check.detected = text.split()[-1]
    check.ok = check.detected.startswith(EXPECTED["cuda_runtime"])
    return check


def run_check(fn: Callable[[], Check]) -> Check:
    try:
        return fn()
    except Exception as exc:
        return Check(fn.__name__.removeprefix("check_"), "unknown",
                     f"{type(exc).__name__}: {exc}")


CHECKS: list[Callable[[], Check]] = [check_l4t_release, check_tegra_kernel, check_cuda_runtime]


def report(checks: list[Check]) -> None:
    width = max(len(c.name) for c in checks)
    for c in checks:
        mark = "  OK  " if c.ok else " FAIL "
        print(f"[{mark}] {c.name:<{width}}  expected {c.expected:<10}  detected {c.detected}")


if __name__ == "__main__":
    report([run_check(fn) for fn in CHECKS])

$ uv run python -m labs.jetpack_verify   # right after the flash, before any SDK components
[  OK  ] l4t_release   expected R36.4.3     detected R36.4.3
[  OK  ] tegra_kernel  expected -tegra      detected 5.15.148-tegra
[ FAIL ] cuda_runtime  expected 12.6        detected no file at /usr/local/cuda/version.txt

Two things are borrowed here and one is new. ok starts False and detected starts at "not read", so a check that returns early or dies halfway reports the truth about how far it got; Chapter 58's run_check does the rest, converting any exception into a row instead of an aborted run, which matters more here than it did there because a half-flashed board is exactly where a check hits something it never expected. The new part is the pairing. Every row carries the value the installer produced and the value JetPack 6.2.2 is documented to produce, side by side, and ok is nothing but the comparison between them. A detected version alone is a fact you then have to look up. A detected version beside its expectation is an answer.

The kernel row asks a question the release banner cannot. That banner is a text file, and a text file survives being copied onto a board running any kernel at all. platform.release() reports the kernel the machine actually booted, and the -tegra suffix is NVIDIA's build, carrying the drivers for the GPU and the camera and the rest of the silicon. Generic arm64 Ubuntu on this hardware boots, looks normal, and has no GPU.

# labs/jetpack_verify.py — continued
def check_cuda_toolkit() -> Check:
    check = Check("cuda_toolkit", "nvcc on disk")
    nvcc = CUDA_ROOT / "bin" / "nvcc"
    if not nvcc.is_file():
        check.detected = f"no nvcc under {CUDA_ROOT}"
        return check
    check.detected = str(nvcc)
    check.ok = True
    return check


CHECKS: list[Callable[[], Check]] = [
    check_l4t_release, check_tegra_kernel, check_cuda_runtime, check_cuda_toolkit,
]

$ uv run python -m labs.jetpack_verify   # after SDK Manager finished installing the components
[  OK  ] l4t_release   expected R36.4.3     detected R36.4.3
[  OK  ] tegra_kernel  expected -tegra      detected 5.15.148-tegra
[ FAIL ] cuda_runtime  expected 12.6        detected no file at /usr/local/cuda/version.txt
[  OK  ] cuda_toolkit  expected nvcc on disk  detected /usr/local/cuda/bin/nvcc

CUDA arrives as two different kinds of thing and they install independently. The runtime is a set of shared libraries that a compiled program loads when it starts, and it is all a machine needs to run GPU code somebody else built. The toolkit adds the compiler nvcc and the headers, and it is what a machine needs to build GPU code, including the moment a Python package with CUDA sources decides to compile itself during installation. A board with the runtime and no toolkit runs prebuilt wheels happily and fails every source build, with an error message that blames the package. Asking two questions instead of one costs four lines and tells you which half is missing.

Now look at rows three and four together, because they contradict each other. The compiler is on disk, at a path inside the CUDA installation, and the check that says CUDA is absent is reading a file inside that same directory. Both cannot be right.

# labs/jetpack_verify.py — the ending
import sys


def report(checks: list[Check]) -> bool:
    width = max(len(c.name) for c in checks)
    for c in checks:
        mark = "  OK  " if c.ok else " FAIL "
        print(f"[{mark}] {c.name:<{width}}  expected {c.expected:<13}  detected {c.detected}")
    agreed = sum(1 for c in checks if c.ok)
    print(f"{agreed}/{len(checks)} claims agree with JetPack 6.2.2.")
    return agreed == len(checks)


if __name__ == "__main__":
    sys.exit(report([run_check(fn) for fn in CHECKS]))

$ uv run python -m labs.jetpack_verify; echo "exit=$?"   # bench capture, your versions will vary
[  OK  ] l4t_release   expected R36.4.3        detected R36.4.3
[  OK  ] tegra_kernel  expected -tegra         detected 5.15.148-tegra
[  OK  ] cuda_runtime  expected 12.6           detected 12.6.11
[  OK  ] cuda_toolkit  expected nvcc on disk   detected /usr/local/cuda/bin/nvcc
4/4 claims agree with JetPack 6.2.2.
exit=1

Four green rows and an exit code of 1. Handing sys.exit anything other than None or an integer makes Python convert it, and int(True) is 1, which every shell on the planet reads as failure. The passing run just told your future automation that the flash was bad. Write the conversion out yourself, sys.exit(0 if report(...) else 1), and the same run ends at exit=0. Keep the exit code even while you run this by hand: a verdict another program can read is what lets this drop into a startup routine later, and it costs one line.