From 32f190f58ba25b0e57bbb4df1aac964a884366f7 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 16:14:26 -0500 Subject: [PATCH 01/30] lib: Add getFlakeInput helper See the next commit. --- lib/default.nix | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/lib/default.nix b/lib/default.nix index 64e8ff3..7100cfe 100644 --- a/lib/default.nix +++ b/lib/default.nix @@ -42,6 +42,17 @@ let ) dir ) ); + + /** + Returns the Flake lock information for the given input name on this Flake. + */ + getFlakeInput = + name: + let + data = builtins.fromJSON (builtins.readFile ../flake.lock); + nodeName = data.nodes.root.inputs.${name}; + in + data.nodes.${nodeName}; }; in self From 7d43270ba748a07d5cf5cdd2dd1aa031b6f32f75 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 16:14:46 -0500 Subject: [PATCH 02/30] lib: Add lockedNixpkgsVersion This will be used to make the style check only apply to the locked Nixpkgs version. --- lib/default.nix | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/lib/default.nix b/lib/default.nix index 7100cfe..a45f90b 100644 --- a/lib/default.nix +++ b/lib/default.nix @@ -53,6 +53,14 @@ let nodeName = data.nodes.root.inputs.${name}; in data.nodes.${nodeName}; + + /** + The default locked Nixpkgs version number. For example, 26.05. + This can be used to check for overridden inputs. + */ + lockedNixpkgsVersion = builtins.head ( + builtins.match ".*/nixos-([0-9]+\\.[0-9]+).*" (self.getFlakeInput "nixpkgs").locked.url + ); }; in self From ab5481cb21c4826fc4b353bee92dd0c8f196f8cf Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 17:02:07 -0500 Subject: [PATCH 03/30] checks/pre-commit: Drop redundant and incorrect styleCheckRequired It's redundant because at the `flake.nix` level this was already being handled. It's wrong because it's using the `lib` from the `flake-parts` input, which ***is not*** the `lib` from the `nixpkgs` or `pkgs` input! So whatever override we were passing for `nixpkgs` wouldn't affect that `lib`, and thus the `version` on the `lib` was whatever the `flake-parts`'s Nixpkgs was at. --- checks/pre-commit.nix | 39 ++++++++++++++++----------------------- 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/checks/pre-commit.nix b/checks/pre-commit.nix index f3eece1..933e3ba 100644 --- a/checks/pre-commit.nix +++ b/checks/pre-commit.nix @@ -3,7 +3,6 @@ perSystem = { config, - lib, pkgs, ... }: @@ -14,30 +13,24 @@ shellHook = config.pre-commit.installationScript; }; - pre-commit = - let - styleCheckRequired = lib.versionAtLeast lib.version "25.11"; - in - { - check.enable = lib.warnIfNot ( - styleCheckRequired - ) "Style Check disabled, because we do not use the latest nixpkgs version" styleCheckRequired; - settings = { - package = pkgs.pre-commit; - excludes = [ - ]; - hooks = { - shfmt = { - enable = true; - raw.entry = " --indent 2"; - }; - nixfmt.enable = true; - deadnix.enable = true; - shellcheck.enable = true; - trim-trailing-whitespace.enable = true; - check-executables-have-shebangs.enable = true; + pre-commit = { + check.enable = true; + settings = { + package = pkgs.pre-commit; + excludes = [ + ]; + hooks = { + shfmt = { + enable = true; + raw.entry = " --indent 2"; }; + nixfmt.enable = true; + deadnix.enable = true; + shellcheck.enable = true; + trim-trailing-whitespace.enable = true; + check-executables-have-shebangs.enable = true; }; }; + }; }; } From dc5d6ebb89213e75ff874ea9a665239a3aeb8755 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 17:09:27 -0500 Subject: [PATCH 04/30] flake: Only run pre-commit checks against the locked Nixpkgs This is one way Flakes let us down: there is no way to make the `check` run only when inputs were not overridden, or additional ways to affect the evaluation. So, just like Sisyphus, we need to push the version number up every time the formatting rules change in the formatter that is on the `nixos-unstable` release we track, compared to whichever versions we run as additional CI checks. Instead of handling this manually, let's just look at the locked version number from the release channel URL. --- flake.nix | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index 62b26cb..d405941 100644 --- a/flake.nix +++ b/flake.nix @@ -26,7 +26,12 @@ ./packages/flakeModule.nix ] ++ - inputs.nixpkgs.lib.optionals (inputs.nixpkgs.lib.versionAtLeast inputs.nixpkgs.lib.version "25.11") + # Only run the `pre-commit` checks when ran using the locked Nixpkgs. + # This ensures our CI isn't running those checks when we override the Nixpkgs input. + inputs.nixpkgs.lib.optionals + (inputs.nixpkgs.lib.versionAtLeast inputs.nixpkgs.lib.version + (import ./lib { lib = { }; }).lockedNixpkgsVersion + ) [ inputs.preCommitHooksNix.flakeModule ./checks/pre-commit.nix From 094bb37e4b830c379b8bfe9c974afd3274a2f86e Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 17:30:07 -0500 Subject: [PATCH 05/30] nvidia/jetson-orin-nano-super: Expose nvidia-oot as a kernelPackage This unshackles the evaluation of the package from the NixOS evaluation. --- .../nvidia/jetson-orin-nano-super/default.nix | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index c71ab5b..6e8000a 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -26,8 +26,18 @@ in boot.extraModulePackages = lib.mkMerge [ (lib.mkIf cfg.enableOotModules [ - (config.boot.kernelPackages.callPackage ./nvidia-oot { }) + config.boot.kernelPackages.nvidia-oot ]) ]; + + nixpkgs.overlays = [ + (final: super: { + kernelPackagesExtensions = (super.kernelPackagesExtensions or []) ++ [ + (kFinal: kSuper: { + nvidia-oot = kFinal.callPackage ./nvidia-oot { }; + }) + ]; + }) + ]; }; } From ce7f86d27365c1b6651fb5878e2be48b44e1aa5f Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 18:46:12 -0500 Subject: [PATCH 06/30] jetson-orin-nano-super/nvidia-oot: rel-36_eng_2026-01-04 -> r36.5 Turns out we already basically were at r36.5, and this will have been the cause of some of the issues getting the GPU drivers going. --- .../nvidia/jetson-orin-nano-super/nvidia-oot/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix index 6c4733d..112fa35 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix @@ -14,11 +14,11 @@ # }) srcs ? let - rev = "rel-36_eng_2026-01-04"; + rev = "jetson_36.5"; repos = { "linux-hwpm" = "sha256-LrCtuQIbHxBibJaMnrNYEAegtezUDUPGiHJDW+0qHA8="; "linux-nvgpu" = "sha256-zvnTygjF8BUNxaqcU4Mt6kAwngFpArM5timpjw074uQ="; - "linux-nv-oot" = "sha256-Vt4ef0GIFpk34IPCIL7/R6Jsssd90GXLKonIY8P4e5s="; + "linux-nv-oot" = "sha256-6sqz+yiG8VfJ5/QHn13a60TKqdwl1LuJfV3jCPoJxp4="; }; in builtins.mapAttrs ( From 9beaa362e2c5dd5a7b3a995fcca98d7a7759e238 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 18:49:26 -0500 Subject: [PATCH 07/30] jetson-orin-nano-super/nvidia-oot: Minor cleanups --- .../nvidia/jetson-orin-nano-super/nvidia-oot/default.nix | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix index 112fa35..995e6d9 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix @@ -58,7 +58,7 @@ kernel.stdenv.mkDerivation (finalAttrs: { nativeBuildInputs = kernel.moduleBuildDependencies; postPatch = '' - printf '\n:: Disabling nvethernet driver...\n' + printf '\n :: Disabling nvethernet driver...\n' # Not needed on supported hardware, requires additional repository setup. echo "# disabled" > "$workspace/linux-nv-oot/drivers/net/ethernet/nvidia/nvethernet/Makefile" ''; @@ -186,7 +186,6 @@ kernel.stdenv.mkDerivation (finalAttrs: { let replacements = { "buildFlags" = "installFlags installTargets"; - "buildPhase" = "installPhase"; "postBuild" = "postInstall"; "preBuild" = "preInstall"; "Building" = "Installing"; From eeb05cf64609bacba6351313f4c17ab45b497d3f Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 20:41:16 -0500 Subject: [PATCH 08/30] jetson-orin-nano-super/nvidia-oot: Build nv-kernel-display-driver This is *basically* the open GPU driver codebase, but in a special Tegra configuration. It also is a different branch, with a version number that may not be matching anything equivalent on the open GPU drivers. This is not sufficient to have hardware acceleration. The proprietary drivers also have to be used. The proprietary driver version *must* match the version of the this display driver, or else things may not work, or worse. --- .../nvidia-oot/default.nix | 82 +++++++++++++++++-- 1 file changed, 76 insertions(+), 6 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix index 995e6d9..c1b860f 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix @@ -19,6 +19,7 @@ "linux-hwpm" = "sha256-LrCtuQIbHxBibJaMnrNYEAegtezUDUPGiHJDW+0qHA8="; "linux-nvgpu" = "sha256-zvnTygjF8BUNxaqcU4Mt6kAwngFpArM5timpjw074uQ="; "linux-nv-oot" = "sha256-6sqz+yiG8VfJ5/QHn13a60TKqdwl1LuJfV3jCPoJxp4="; + "tegra/kernel-src/nv-kernel-display-driver" = "sha256-MjiircE+B8r15QAEt/ZZiWPV7yZd6/2CuJnbc6Z2YiU="; }; in builtins.mapAttrs ( @@ -43,12 +44,20 @@ kernel.stdenv.mkDerivation (finalAttrs: { runHook preUnpack ${lib.concatStringsSep "\n" ( - lib.mapAttrsToList (name: src: '' - printf '\n:: Copying %q to workspace\n' "${name}" - mkdir -p ./${name} - cp -rt ./${name} ${src}/* - chmod -R +w ./${name} - '') srcs + lib.mapAttrsToList ( + repo: src: + let + # The repos are keyed by GitLab project structure. + # We're flattening it to the basename of the repos. + name = builtins.baseNameOf repo; + in + '' + printf '\n :: Copying %q to workspace\n' "${name}" + mkdir -p ./${name} + cp -rt ./${name} ${src}/* + chmod -R +w ./${name} + '' + ) srcs )} export workspace="$PWD" @@ -61,6 +70,25 @@ kernel.stdenv.mkDerivation (finalAttrs: { printf '\n :: Disabling nvethernet driver...\n' # Not needed on supported hardware, requires additional repository setup. echo "# disabled" > "$workspace/linux-nv-oot/drivers/net/ethernet/nvidia/nvethernet/Makefile" + + printf '\n :: Ensuring open kernel modules build succeeds\n' + # The open display drivers build is kinda broken, and needs to happen in two stages + # 1. build the "OS agnostic portions" + # 2. build the Linux kernel modules + # The handling for stage 2 loses all the makeFlags. + # So instead we'll just run the command ourselves... + substituteInPlace nv-kernel-display-driver/Makefile \ + --replace-fail '$(MAKE) -C kernel-open modules' '# (make modules handled externally)' + + # Add the OOT symbols for feature detection. + # Vendor merges the kernel symvers with oot symvers. + substituteInPlace nv-kernel-display-driver/kernel-open/conftest.sh \ + --replace-fail '"$OUTPUT/Module.symvers" >/dev/null' '"$OUTPUT/Module.symvers" "$workspace/linux-nv-oot/Module.symvers" >/dev/null' + + # Patch in our added CFLAGS into the display driver conftest. + # This differs from the nv-oot conftest. + substituteInPlace nv-kernel-display-driver/kernel-open/Kbuild \ + --replace-fail 'NV_CONFTEST_CFLAGS =' 'NV_CONFTEST_CFLAGS = $(KCFLAGS)' ''; configurePhase = '' @@ -136,6 +164,16 @@ kernel.stdenv.mkDerivation (finalAttrs: { "NV_OOT_BLOCK_TEGRA_VIRT_STORAGE_SKIP_BUILD=y" ]; + # These CFGLAGS are for the nv-kernel-display-driver build. + # No other mechanism allowed getting through to it. + KCFLAGS = lib.concatStringsSep " " [ + "-I$(srctree.nvidia-oot)/include" + # The following three flags are used to make conftest work. + "-std=gnu11" + "-fshort-wchar" + "-Wno-incompatible-pointer-types" + ]; + buildFlags = [ "modules" ]; @@ -172,6 +210,33 @@ kernel.stdenv.mkDerivation (finalAttrs: { printf '\n :: Building nvgpu\n' _make "M=$workspace/linux-nvgpu/drivers/gpu/nvgpu" + # This build step differs from the three previous ones, just as it does in the downstream oot Makefile. + if [[ "$curPhase" == "buildPhase" ]]; then + printf '\n :: Building nv-kernel-display-driver OS-agnostic portions\n' + + # `NV_BUILD_HOSTNAME` is used in newer releases, `HOSTNAME` was previously used. + _make -C "$workspace/nv-kernel-display-driver" \ + HOSTNAME="nixos" \ + NV_BUILD_HOST="nixos" \ + NV_BUILD_USER="nixos" \ + TARGET_OS=Linux \ + TARGET_ARCH=${kernel.stdenv.hostPlatform.uname.processor} \ + "SYSSRC=${kernel.dev}/lib/modules/${kernel.modDirVersion}/source" \ + "SYSOUT=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build" \ + 'MODLIB=$(out)/lib/modules/${kernel.modDirVersion}' \ + "DATE=" \ + KERNELRELEASE="" + LOCALVERSION='$(version)' + fi + + # NOTE: The open driver's own conftest.sh is being ran in this command. + printf '\n :: Building nv-kernel-display-driver module\n' + _make \ + -C "$workspace/nv-kernel-display-driver/kernel-open" \ + SYSSRC="${kernel.dev}/lib/modules/${kernel.modDirVersion}/source" \ + SYSOUT="${kernel.dev}/lib/modules/${kernel.modDirVersion}/build" \ + SYSSRCHOST1X="$workspace/linux-nv-oot/drivers/gpu/host1x/include" + runHook postBuild ''; @@ -232,6 +297,11 @@ kernel.stdenv.mkDerivation (finalAttrs: { # linux-nv-oot # SPDX-License-Identifier: BSD-3-Clause lib.licenses.bsd3 + + # nv-kernel-display-driver + # SPDX-License-Identifier: MIT + # However, when linked together to form a Linux kernel module, the resulting Linux + # kernel module is dual licensed as MIT/GPLv2. ]; # Vendor supports up to 6.15 as of 2026-01-04. From 55a6f6859ceb080d928837f67489491388c170fc Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 20:43:33 -0500 Subject: [PATCH 09/30] jetson-orin-nano-super/nvidia-oot: Backport fbdev ttm patch to nv-kernel-display-driver This was backported as it looked like it may be able to fix the GPU driver usage with mainline 6.12. It did not. This did fix the `fbdev` parameter for 6.12. --- ...ort-fbdev_ttm-support-from-565.57.01.patch | 241 ++++++++++++++++++ .../nvidia-oot/default.nix | 4 + 2 files changed, 245 insertions(+) create mode 100644 modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/0001-BACKPORT-Backport-fbdev_ttm-support-from-565.57.01.patch diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/0001-BACKPORT-Backport-fbdev_ttm-support-from-565.57.01.patch b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/0001-BACKPORT-Backport-fbdev_ttm-support-from-565.57.01.patch new file mode 100644 index 0000000..8bff122 --- /dev/null +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/0001-BACKPORT-Backport-fbdev_ttm-support-from-565.57.01.patch @@ -0,0 +1,241 @@ +From 4d4f8e4c2efe512c52dd3b03ea00d88896c9dcb9 Mon Sep 17 00:00:00 2001 +From: Samuel Dionne-Riel +Date: Mon, 9 Feb 2026 13:24:41 -0500 +Subject: [PATCH] [BACKPORT] Backport fbdev_ttm support from 565.57.01 + +Signed-off-by: Samuel Dionne-Riel +--- + kernel-open/Kbuild | 1 + + kernel-open/conftest.sh | 50 +++++++++++++++++-- + kernel-open/nvidia-drm/nvidia-drm-drv.c | 29 ++++++++--- + kernel-open/nvidia-drm/nvidia-drm-linux.c | 2 +- + .../nvidia-drm/nvidia-drm-os-interface.h | 8 ++- + kernel-open/nvidia-drm/nvidia-drm.Kbuild | 1 + + 6 files changed, 78 insertions(+), 13 deletions(-) + +diff --git a/nv-kernel-display-driver/kernel-open/Kbuild b/nv-kernel-display-driver/kernel-open/Kbuild +index 64328f16..e80a6d6d 100644 +--- a/nv-kernel-display-driver/kernel-open/Kbuild ++++ b/nv-kernel-display-driver/kernel-open/Kbuild +@@ -227,6 +227,7 @@ NV_HEADER_PRESENCE_TESTS = \ + drm/drm_atomic_uapi.h \ + drm/drm_drv.h \ + drm/drm_fbdev_generic.h \ ++ drm/drm_fbdev_ttm.h \ + drm/drm_framebuffer.h \ + drm/drm_connector.h \ + drm/drm_probe_helper.h \ +diff --git a/nv-kernel-display-driver/kernel-open/conftest.sh b/nv-kernel-display-driver/kernel-open/conftest.sh +index 61ac17d0..6732a940 100644 +--- a/nv-kernel-display-driver/kernel-open/conftest.sh ++++ b/nv-kernel-display-driver/kernel-open/conftest.sh +@@ -6399,9 +6399,11 @@ compile_test() { + # + # Determine whether drm_fbdev_generic_setup is present. + # +- # drm_fbdev_generic_setup was added by commit 9060d7f49376 +- # ("drm/fb-helper: Finish the generic fbdev emulation") in v4.19-rc1 +- # (2018-07-03) ++ # Added by commit 9060d7f49376 ("drm/fb-helper: Finish the ++ # generic fbdev emulation") in v4.19. ++ # generic fbdev emulation") in v4.19. Removed by commit ++ # aae4682e5d66 ("drm/fbdev-generic: Convert to fbdev-ttm") ++ # in v6.11. + # + CODE=" + #include +@@ -6413,6 +6415,48 @@ compile_test() { + }" + + compile_check_conftest "$CODE" "NV_DRM_FBDEV_GENERIC_SETUP_PRESENT" "" "functions" ++ ;; ++ ++ drm_fbdev_ttm_setup) ++ # ++ # Determine whether drm_fbdev_ttm_setup is present. ++ # ++ # Added by commit aae4682e5d66 ("drm/fbdev-generic: ++ # Convert to fbdev-ttm") in v6.11. ++ # ++ CODE=" ++ #include ++ #if defined(NV_DRM_DRM_FBDEV_TTM_H_PRESENT) ++ #include ++ #endif ++ void conftest_drm_fbdev_ttm_setup(void) { ++ drm_fbdev_ttm_setup(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_FBDEV_TTM_SETUP_PRESENT" "" "functions" ++ ;; ++ ++ drm_output_poll_changed) ++ # ++ # Determine whether drm_mode_config_funcs.output_poll_changed ++ # callback is present ++ # ++ # Removed by commit 446d0f4849b1 ("drm: Remove struct ++ # drm_mode_config_funcs.output_poll_changed") in v6.12. Hotplug ++ # event support is handled through the fbdev emulation interface ++ # going forward. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_MODE_CONFIG_H_PRESENT) ++ #include ++ #else ++ #include ++ #endif ++ int conftest_drm_output_poll_changed_available(void) { ++ return offsetof(struct drm_mode_config_funcs, output_poll_changed); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_OUTPUT_POLL_CHANGED_PRESENT" "" "types" + ;; + + drm_output_poll_changed) +diff --git a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-drv.c b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-drv.c +index 87a4acdc..054b5b22 100644 +--- a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-drv.c ++++ b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-drv.c +@@ -62,12 +62,14 @@ + #include + #endif + +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + #include + #include + #endif + +-#if defined(NV_DRM_DRM_FBDEV_GENERIC_H_PRESENT) ++#if defined(NV_DRM_DRM_FBDEV_TTM_H_PRESENT) ++#include ++#elif defined(NV_DRM_DRM_FBDEV_GENERIC_H_PRESENT) + #include + #endif + +@@ -720,7 +722,7 @@ static int nv_drm_load(struct drm_device *dev, unsigned long flags) + return -ENODEV; + } + +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + /* + * If fbdev is enabled, take modeset ownership now before other DRM clients + * can take master (and thus NVKMS ownership). +@@ -786,6 +788,13 @@ static int nv_drm_load(struct drm_device *dev, unsigned long flags) + + ret = nv_drm_create_properties(nv_dev); + if (ret < 0) { ++ drm_mode_config_cleanup(dev); ++#if defined(NV_DRM_FBDEV_AVAILABLE) ++ if (nv_dev->hasFramebufferConsole) { ++ nvKms->releaseOwnership(nv_dev->pDevice); ++ } ++#endif ++ nvKms->freeDevice(nv_dev->pDevice); + return -ENODEV; + } + +@@ -850,7 +859,7 @@ static void __nv_drm_unload(struct drm_device *dev) + + /* Release modeset ownership if fbdev is enabled */ + +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + if (nv_dev->hasFramebufferConsole) { + drm_atomic_helper_shutdown(dev); + nvKms->releaseOwnership(nv_dev->pDevice); +@@ -2045,7 +2054,7 @@ static void nv_drm_register_drm_device(const nv_gpu_info_t *gpu_info) + goto failed_drm_register; + } + +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + if (nv_drm_fbdev_module_param && + drm_core_check_feature(dev, DRIVER_MODESET)) { + +@@ -2077,9 +2086,13 @@ static void nv_drm_register_drm_device(const nv_gpu_info_t *gpu_info) + NV_DRM_DEV_LOG_WARN(nv_dev, "Failed to get framebuffer console info"); + } + } ++ #if defined(NV_DRM_FBDEV_TTM_AVAILABLE) ++ drm_fbdev_ttm_setup(dev, 32); ++ #elif defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) + drm_fbdev_generic_setup(dev, 32); ++ #endif + } +-#endif /* defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) */ ++#endif /* defined(NV_DRM_FBDEV_AVAILABLE) */ + + /* Add NVIDIA-DRM device into list */ + +@@ -2219,12 +2232,12 @@ void nv_drm_suspend_resume(NvBool suspend) + + if (suspend) { + drm_kms_helper_poll_disable(dev); +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + drm_fb_helper_set_suspend_unlocked(dev->fb_helper, 1); + #endif + drm_mode_config_reset(dev); + } else { +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + drm_fb_helper_set_suspend_unlocked(dev->fb_helper, 0); + #endif + drm_kms_helper_poll_enable(dev); +diff --git a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-linux.c b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-linux.c +index e2d6a5ae..690d53ab 100644 +--- a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-linux.c ++++ b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-linux.c +@@ -51,7 +51,7 @@ MODULE_PARM_DESC( + bool nv_drm_modeset_module_param = false; + module_param_named(modeset, nv_drm_modeset_module_param, bool, 0400); + +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + MODULE_PARM_DESC( + fbdev, + "Create a framebuffer device (1 = enable, 0 = disable (default)) (EXPERIMENTAL)"); +diff --git a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-os-interface.h b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-os-interface.h +index 7d0f167e..d7e940c8 100644 +--- a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-os-interface.h ++++ b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm-os-interface.h +@@ -59,14 +59,20 @@ typedef struct nv_timer nv_drm_timer; + #endif /* else defined(NV_LINUX) */ + + #if defined(NV_DRM_FBDEV_GENERIC_SETUP_PRESENT) && defined(NV_DRM_APERTURE_REMOVE_CONFLICTING_PCI_FRAMEBUFFERS_PRESENT) ++#define NV_DRM_FBDEV_AVAILABLE + #define NV_DRM_FBDEV_GENERIC_AVAILABLE + #endif + ++#if defined(NV_DRM_FBDEV_TTM_SETUP_PRESENT) && defined(NV_DRM_APERTURE_REMOVE_CONFLICTING_PCI_FRAMEBUFFERS_PRESENT) ++#define NV_DRM_FBDEV_AVAILABLE ++#define NV_DRM_FBDEV_TTM_AVAILABLE ++#endif ++ + struct page; + + /* Set to true when the atomic modeset feature is enabled. */ + extern bool nv_drm_modeset_module_param; +-#if defined(NV_DRM_FBDEV_GENERIC_AVAILABLE) ++#if defined(NV_DRM_FBDEV_AVAILABLE) + /* Set to true when the nvidia-drm driver should install a framebuffer device */ + extern bool nv_drm_fbdev_module_param; + #endif +diff --git a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm.Kbuild b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm.Kbuild +index f239dc3c..c446b13e 100644 +--- a/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm.Kbuild ++++ b/nv-kernel-display-driver/kernel-open/nvidia-drm/nvidia-drm.Kbuild +@@ -87,6 +87,7 @@ NV_CONFTEST_FUNCTION_COMPILE_TESTS += sync_file_get_fence + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_aperture_remove_conflicting_framebuffers + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_aperture_remove_conflicting_pci_framebuffers + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_fbdev_generic_setup ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_fbdev_ttm_setup + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_helper_crtc_enable_color_mgmt + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_crtc_enable_color_mgmt + NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_sysfs_connector_property_event +-- +2.52.0 + diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix index c1b860f..326852a 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-oot/default.nix @@ -66,6 +66,10 @@ kernel.stdenv.mkDerivation (finalAttrs: { nativeBuildInputs = kernel.moduleBuildDependencies; + patches = [ + ./0001-BACKPORT-Backport-fbdev_ttm-support-from-565.57.01.patch + ]; + postPatch = '' printf '\n :: Disabling nvethernet driver...\n' # Not needed on supported hardware, requires additional repository setup. From 981a40cf364086fed512bf7dbd9b77f66d638de1 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 21:05:56 -0500 Subject: [PATCH 10/30] jetson-orin-nano-super/nvidia-l4t-kernel: Init at r36.5 This is not forced on end-users. This is provided because it *may* be needed to better support all features of the platform. Even with OOT drivers, some features won't work with mainline, or worse. --- .../nvidia/jetson-orin-nano-super/default.nix | 9 ++++ .../nvidia-l4t-kernel/default.nix | 41 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 6e8000a..aeb4d93 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -37,6 +37,15 @@ in nvidia-oot = kFinal.callPackage ./nvidia-oot { }; }) ]; + nvidia-jetson-orin-nano-super = { + nvidia-l4t-kernelPackages = final.linuxPackagesFor final.nvidia-jetson-orin-nano-super.nvidia-l4t-kernel; + nvidia-l4t-kernel = final.callPackage ./nvidia-l4t-kernel { + kernelPatches = [ + final.linuxKernel.kernelPatches.bridge_stp_helper + final.linuxKernel.kernelPatches.request_key_helper + ]; + }; + }; }) ]; }; diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix new file mode 100644 index 0000000..98cfd2d --- /dev/null +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix @@ -0,0 +1,41 @@ +{ + lib, + buildLinux, + fetchFromGitLab, + kernelPatches, + ... +# This needs to forward additional `.override` args to `buildLinux`. +# See `nixos/modules/system/boot/kernel.nix`. +# This is how e.g. `boot.kernelPatches` is implemented. +}@args: + +let + tag = "jetson_36.5"; +in +buildLinux ( + args + // { + version = "5.15.185-${tag}"; + src = fetchFromGitLab { + owner = "nvidia"; + repo = "nv-tegra/3rdparty/canonical/linux-jammy"; + inherit tag; + hash = "sha256-YYp1e641H+ELtke94PNIVvEXDKW9yNVS++Pkz69r1zU="; + }; + inherit kernelPatches; + structuredExtraConfig = { + LOCALVERSION = lib.kernel.freeform ''-${tag}''; + # Driver build is broken from backport of new drivers. + # ../drivers/media/pci/intel/ipu6/../ipu-dma.c:53:17: error: implicit declaration of function 'clflush_cache_range'; did you mean 'flush_cache_range'? [-Werror=implicit-function-declaration] + VIDEO_INTEL_IPU6 = lib.kernel.no; + + FB_SIMPLE = lib.kernel.yes; + # SIMPLEDRM **must** be disabled for the X11 driver. + DRM_SIMPLEDRM = lib.mkForce lib.kernel.no; + + # XZ compressed firmware load is not enabled if not specified. + FW_LOADER_COMPRESS = lib.kernel.yes; + FW_LOADER_COMPRESS_XZ = lib.kernel.yes; + }; + } +) From 064508f798f4bd6b7652e7fef04b485a7a4ac6ab Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 21:23:17 -0500 Subject: [PATCH 11/30] jetson-orin-nano-super/nvidia-l4t{,-firmware}: Init at r36.5 The `nvidia-l4t` package includes the proprietary libraries, the ones we don't have the equivalent sources to. These libraries are where the GPU acceleration lives. --- .../nvidia/jetson-orin-nano-super/default.nix | 9 + .../nvidia-l4t-firmware/default.nix | 50 +++ .../nvidia-l4t/default.nix | 206 +++++++++++++ .../nvidia-l4t/nvidia-l4t-packages.json | 290 ++++++++++++++++++ 4 files changed, 555 insertions(+) create mode 100644 modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-firmware/default.nix create mode 100644 modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix create mode 100644 modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/nvidia-l4t-packages.json diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index aeb4d93..77b6baf 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -30,6 +30,9 @@ in ]) ]; + # We can add the proprietary packages to the overlay even without enabling the + # *configuration* for proprietary packages. This leaves it up to the end-user + # to use those proprietary packages. nixpkgs.overlays = [ (final: super: { kernelPackagesExtensions = (super.kernelPackagesExtensions or []) ++ [ @@ -38,6 +41,12 @@ in }) ]; nvidia-jetson-orin-nano-super = { + nvidia-l4t = final.callPackage ./nvidia-l4t { }; + nvidia-l4t-firmware = final.callPackage ./nvidia-l4t-firmware { + inherit (final.nvidia-jetson-orin-nano-super) + nvidia-l4t + ; + }; nvidia-l4t-kernelPackages = final.linuxPackagesFor final.nvidia-jetson-orin-nano-super.nvidia-l4t-kernel; nvidia-l4t-kernel = final.callPackage ./nvidia-l4t-kernel { kernelPatches = [ diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-firmware/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-firmware/default.nix new file mode 100644 index 0000000..c0a4a4d --- /dev/null +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-firmware/default.nix @@ -0,0 +1,50 @@ +{ + lib, + stdenv, + fetchurl, + dpkg, + nvidia-l4t, +}: + +stdenv.mkDerivation (finalAttrs: { + pname = "nvidia-l4t-firmware"; + inherit (nvidia-l4t) version; + + src = fetchurl nvidia-l4t.sources."t234".${finalAttrs.version}.packages.nvidia-l4t-firmware; + unpackPhase = '' + runHook preUnpack + + printf '\n:: Extracting package %q\n' "${finalAttrs.pname}" + dpkg -x "$src" ./ + + runHook postUnpack + ''; + + nativeBuildInputs = [ + dpkg + ]; + + installPhase = '' + runHook preInstall + + # Drop misc. BSP-provided firmware. + ( + cd lib/firmware + rm -rfv brcm* rtl* nv-{BT,WIFI}-Version + ) + + mkdir -vp $out/lib + mv -vt $out/lib lib/firmware + + runHook postInstall + ''; + + dontPatchELF = true; + dontStrip = true; + + meta = { + licenses = [ + lib.licenses.unfree + ]; + }; +}) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix new file mode 100644 index 0000000..040119a --- /dev/null +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix @@ -0,0 +1,206 @@ +let + # NOTE: This is not exposed in the arguments for this callPackage-pattern + # package, as it wouldn't work in overriding as expected. + # This version is used for `fetchurl` and for the `mkDerivation` later. + # NOTE: This needs to be updated and match with the compatible `nvidia-oot` version. + version = "36.5.0"; + sources = builtins.fromJSON (builtins.readFile ./nvidia-l4t-packages.json); +in +{ + lib, + stdenv, + fetchurl, + autoPatchelfHook, + dpkg, + + coreutils, + expat, + libxcb, + libxext, + libX11, + libGL, + libdrm, + libgbm, + libffi, + dbus, + + srcs ? builtins.listToAttrs ( + builtins.map + (name: { + inherit name; + value = fetchurl sources."t234".${version}.packages.${name}; + }) + [ + "nvidia-l4t-core" + "nvidia-l4t-3d-core" + "nvidia-l4t-gbm" + + # egl-wayland + "nvidia-l4t-wayland" + "nvidia-l4t-libwayland-egl1" + # Dep for `nvidia-l4t-wayland` + "nvidia-l4t-libwayland-client0" + # Dep for `nvidia-l4t-wayland` + "nvidia-l4t-libwayland-server0" + # vksc-core + "nvidia-l4t-vulkan-sc" + + # libnvcuvid + #"nvidia-l4t-multimedia" + # libcuda + "nvidia-l4t-cuda" + # Deps for cuda + "nvidia-l4t-nvsci" + # libnvidia-ml + "nvidia-l4t-nvml" + + # Configuration files that end-up being required + "nvidia-l4t-init" + ] + ), +}: + +# Listing found here: +# - https://repo.download.nvidia.com/jetson/ + +stdenv.mkDerivation (finalAttrs: { + pname = "nvidia-l4t"; + inherit version; + + unpackPhase = '' + runHook preUnpack + + ${lib.concatStringsSep "\n" ( + # We can extract all packages at once, as they shouldn't conflict with eachother. + # This way we don't need to bother with juggling all those directory structures, + # it's already in the form of the installed system. + lib.mapAttrsToList (name: src: '' + printf '\n:: Extracting package %q\n' "${name}" + dpkg -x "${src}" ./ + '') srcs + )} + + runHook postUnpack + ''; + + # These dependencies are patchelf'd with the autoPatchelfHook. + # Their runpaths are also being added unconditionally for `dlopen()` reasons. + runtimeDependencies = [ + stdenv.cc.cc + expat + libxcb + libxext + libX11 + libGL + libdrm + libgbm + libffi + # Used at runtime by `libnvidia-*glcore.so`... + dbus.lib + ]; + + buildInputs = + # Dependencies being patchelf'd, to satisfy autoPatchelfHook + finalAttrs.runtimeDependencies; + + nativeBuildInputs = [ + autoPatchelfHook + dpkg + ]; + + installPhase = '' + runHook preInstall + + for el in usr/lib/aarch64-linux-gnu/*; do + if test -L "$el"; then + rm -v "$el" + fi + done + rm -v usr/lib/aarch64-linux-gnu/*/ld.so.conf + + mkdir -vp $out/{lib,share} + mv -vt $out/share usr/share/doc + mv -vt $out/lib usr/lib/aarch64-linux-gnu/*/* + mv -vt $out/lib usr/lib/xorg + + mkdir -vp $out/share/egl/egl_external_platform.d/ + mv -t $out/share/egl/egl_external_platform.d/ usr/share/egl/egl_external_platform.d/nvidia_gbm.json + + mkdir -vp "$out/lib/udev/rules.d" + mv -t $out/lib/udev/rules.d etc/udev/rules.d/99-tegra-devices.rules + substituteInPlace $out/lib/udev/rules.d/99-tegra-devices.rules \ + --replace-fail "/bin/mknod" "${lib.getExe' coreutils "mknod"}" + + ( + set -x + + cd $out/lib + + mkdir -vp ../share/vulkan/icd.d + mv -v nvidia_icd.json ../share/vulkan/icd.d/nvidia_icd.aarch64.json + substituteInPlace ../share/vulkan/icd.d/nvidia_icd.aarch64.json \ + --replace-fail "libGLX_nvidia.so.0" "$PWD/libGLX_nvidia.so.0" + + mkdir -vp ../share/glvnd/egl_vendor.d/ + mv -v nvidia.json ../share/glvnd/egl_vendor.d/30_nvidia.json + substituteInPlace ../share/glvnd/egl_vendor.d/30_nvidia.json \ + --replace-fail "libEGL_nvidia.so.0" "$PWD/libEGL_nvidia.so.0" + + substituteInPlace ../share/egl/egl_external_platform.d/nvidia_gbm.json \ + --replace-fail "libnvidia-egl-gbm.so.1" "$PWD/libnvidia-egl-gbm.so.1" + + mkdir -p gbm + # Fixup libnvidia-allocator links we broke + for lib in tegra-udrm_gbm.so tegra_gbm.so nvidia-drm_gbm.so; do + mv -t gbm "$lib" + ln -fs ../libnvidia-allocator.so "gbm/$lib" + done + ) + + runHook postInstall + + # Work around autoPatchelfHook idiosyncrasy... + # We are not handling the whole patching ourselves since we want to rely + # on the autoPatchelfHook "missing dependencies" support. + fixupNvidiaL4T() { + ( + set -x + cd $out/lib + + rpath="$( + # Add "self" to the rpath + printf "${placeholder "out"}/lib" + # And all runtimeDependencies + printf ":%s" ''${runtimeDependenciesArray[@]/%//lib} + )" + + # Apparently `runtimeDependencies` and `appendRunPaths` are only + # effective for .so where the autoPatchelfHook changed the .so... + # Let's make sure any `dlopen`, such as found in `libnvos`, works. + for lib in $(find -type f -name '*.so*'); do + patchelf --add-rpath "$rpath" "$lib" + done + ) + } + + # This needs to run *after* the autoPatchelfHook... + # This is why we're adding this "late". + printf "Adding fixupNvidiaL4T hook\n" + postFixupHooks+=( fixupNvidiaL4T ) + ''; + + # Don't strip "unnecessary" rpath values out + dontPatchELF = true; + # Also don't even try stripping vendor libraries. + dontStrip = true; + + passthru = { + inherit sources; + }; + + meta = { + licenses = [ + lib.licenses.unfree + ]; + }; +}) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/nvidia-l4t-packages.json b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/nvidia-l4t-packages.json new file mode 100644 index 0000000..8695a70 --- /dev/null +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/nvidia-l4t-packages.json @@ -0,0 +1,290 @@ +{ + "t234": { + "36.5.0": { + "platform": "t234", + "arch": "arm64", + "sdk": "36.5.0", + "release": "36.5.0-20260115194252", + "date": { + "year": "2026", + "month": "01", + "day": "15", + "hour": "19", + "minute": "42", + "seconds": "52" + }, + "packages": { + "nvidia-l4t-dla-compiler": { + "name": "nvidia-l4t-dla-compiler_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/common/pool/main/n/nvidia-l4t-dla-compiler/nvidia-l4t-dla-compiler_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-qquGTahUBBD5xpyMqIbMeZAOVqHnx3ptGPYA+007COo=" + }, + "nvidia-l4t-gstreamer": { + "name": "nvidia-l4t-gstreamer_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/common/pool/main/n/nvidia-l4t-gstreamer/nvidia-l4t-gstreamer_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-GIGJ4AWuuURaozE0VzBWz4KyA6mJwz51+meY+4Jl4+g=" + }, + "nvidia-l4t-jetson-multimedia-api": { + "name": "nvidia-l4t-jetson-multimedia-api_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/common/pool/main/n/nvidia-l4t-jetson-multimedia-api/nvidia-l4t-jetson-multimedia-api_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-cPTdr+L3hn3BV8c5lR8i/t2nfEaeydLeU3NRBsP6wUI=" + }, + "nvidia-igx-bootloader": { + "name": "nvidia-igx-bootloader_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-igx-bootloader/nvidia-igx-bootloader_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-tigc6gOhCQmHFJygQlpzK5AYfKCj/rHdQMhw52xdB8w=" + }, + "nvidia-igx-oem-config": { + "name": "nvidia-igx-oem-config_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-igx-oem-config/nvidia-igx-oem-config_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-IefkWaGElnOMkbOkjLbaw9bcoWvGgDkDvGSJzl6fOmI=" + }, + "nvidia-igx-systemd-reboot-hooks": { + "name": "nvidia-igx-systemd-reboot-hooks_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-igx-systemd-reboot-hooks/nvidia-igx-systemd-reboot-hooks_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-JcbBABLQDv9fm7IttlYcr2Q4s+KGB/GgFcvM+oU28xk=" + }, + "nvidia-l4t-3d-core": { + "name": "nvidia-l4t-3d-core_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-3d-core/nvidia-l4t-3d-core_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-kQsWcRzRTzlplHXkLB6TFq1abPcluRQvXruWr3vPSdc=" + }, + "nvidia-l4t-apt-source": { + "name": "nvidia-l4t-apt-source_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-apt-source/nvidia-l4t-apt-source_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-UNPQ+YHl7WxG0BnH2VrAuK7fMpws04HEMnrCg1HaohU=" + }, + "nvidia-l4t-bootloader": { + "name": "nvidia-l4t-bootloader_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-bootloader/nvidia-l4t-bootloader_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-081SSTengnm2DGjjqTloOacnxPqD/YCugOF0n21aASc=" + }, + "nvidia-l4t-camera": { + "name": "nvidia-l4t-camera_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-camera/nvidia-l4t-camera_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-e1TmLOVLCSiNpPLZL6+K1cPjmfseRcMfXi1lQ2gAjw0=" + }, + "nvidia-l4t-configs": { + "name": "nvidia-l4t-configs_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-configs/nvidia-l4t-configs_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-7QK/XUFdN+NY0H12Uao2lywon33EW+j/anbSMLb4v6E=" + }, + "nvidia-l4t-core": { + "name": "nvidia-l4t-core_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-core/nvidia-l4t-core_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-88AvdAJc09ra2x4tvJekGWP4ZGInZCfD1Xi4y5lMVtY=" + }, + "nvidia-l4t-cuda-utils": { + "name": "nvidia-l4t-cuda-utils_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-cuda-utils/nvidia-l4t-cuda-utils_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-p/SEGxH0xM0VUISRiDoTSoamxROpK6V8uOs1REmRcyo=" + }, + "nvidia-l4t-cuda": { + "name": "nvidia-l4t-cuda_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-cuda/nvidia-l4t-cuda_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-i3KR8rIA1URZ2rSK4it6BHvT0yVb9+Ra1L7rMO4Kvdg=" + }, + "nvidia-l4t-dgpu-tools": { + "name": "nvidia-l4t-dgpu-tools_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-dgpu-tools/nvidia-l4t-dgpu-tools_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-Ofo+qOJtHbsPgtdiJeU/LIaVIhlGzjT5XmATYCHohIk=" + }, + "nvidia-l4t-display-kernel_5.15.185-tegra": { + "name": "nvidia-l4t-display-kernel_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-display-kernel/nvidia-l4t-display-kernel_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-zBSlMVp0NN1iR/jvPIWLzJMLXRp9H2QsYfPqJFqUgyY=" + }, + "nvidia-l4t-factory-service": { + "name": "nvidia-l4t-factory-service_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-factory-service/nvidia-l4t-factory-service_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-QXXj8hYVRgd979Olly7oWtX9EPw3rXT0gs7UWZJVCcU=" + }, + "nvidia-l4t-firmware": { + "name": "nvidia-l4t-firmware_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-firmware/nvidia-l4t-firmware_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-MKwWdujHBQb2LcOKNuZ2aC6cdR/KwdB9ciXTCRF1K5Q=" + }, + "nvidia-l4t-gbm": { + "name": "nvidia-l4t-gbm_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-gbm/nvidia-l4t-gbm_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-+Bjht2jQy30F4IBBV7zLA9CPus1ZzaUBpnDvJojGAyU=" + }, + "nvidia-l4t-graphics-demos": { + "name": "nvidia-l4t-graphics-demos_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-graphics-demos/nvidia-l4t-graphics-demos_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-ndJU7ogDVdr5nPHcajDnnqgGCmfESqqWFJZrXtZAom4=" + }, + "nvidia-l4t-init": { + "name": "nvidia-l4t-init_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-init/nvidia-l4t-init_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-CDqeubRiUHMwn0Z9SoWDPv12mKdqF1obxAWEqKml18Y=" + }, + "nvidia-l4t-initrd": { + "name": "nvidia-l4t-initrd_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-initrd/nvidia-l4t-initrd_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-w5xvHQkBgfNmfUmLKMBtwVPEriFG/NNRO7Tn/A+vLng=" + }, + "nvidia-l4t-jetson-io": { + "name": "nvidia-l4t-jetson-io_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-jetson-io/nvidia-l4t-jetson-io_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-oXPqvJlWZiQyiOSpmPPc99HovYMze/2nsL73HmUA6LY=" + }, + "nvidia-l4t-jetson-orin-nano-qspi-updater": { + "name": "nvidia-l4t-jetson-orin-nano-qspi-updater_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-jetson-orin-nano-qspi-updater/nvidia-l4t-jetson-orin-nano-qspi-updater_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-FhJb7afhvfJVZPZ4ZP+wa8nb5AxC94Z+mqGj8jdb1m4=" + }, + "nvidia-l4t-jetsonpower-gui-tools": { + "name": "nvidia-l4t-jetsonpower-gui-tools_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-jetsonpower-gui-tools/nvidia-l4t-jetsonpower-gui-tools_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-zYURessmvSuHf2mLwROHLJVQCd3sZWKQ2amuYTMqKR0=" + }, + "nvidia-l4t-kernel-dtbs_5.15.185-tegra": { + "name": "nvidia-l4t-kernel-dtbs_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-kernel-dtbs/nvidia-l4t-kernel-dtbs_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-w1ryjEPdSb443OdFzyx6JM5j8YgSLGx3eBUKJF+PePA=" + }, + "nvidia-l4t-kernel-headers_5.15.185-tegra": { + "name": "nvidia-l4t-kernel-headers_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-kernel-headers/nvidia-l4t-kernel-headers_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-cisvZpxNm2FDD7YNfk3HCmG/+9+Me0qvABWHm/xbh8E=" + }, + "nvidia-l4t-kernel-oot-headers_5.15.185-tegra": { + "name": "nvidia-l4t-kernel-oot-headers_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-kernel-oot-headers/nvidia-l4t-kernel-oot-headers_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-hUDQ4nERjLLUxL1+d3vYW8LsBDI7K+o0GWZBMxAFLDU=" + }, + "nvidia-l4t-kernel-oot-modules_5.15.185-tegra": { + "name": "nvidia-l4t-kernel-oot-modules_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-kernel-oot-modules/nvidia-l4t-kernel-oot-modules_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-KZHPqQwwCsVZSGoBkMDH8NqzIR3kUibiucoX0jcw5I0=" + }, + "nvidia-l4t-kernel_5.15.185-tegra": { + "name": "nvidia-l4t-kernel_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-kernel/nvidia-l4t-kernel_5.15.185-tegra-36.5.0-20260115194252_arm64.deb", + "hash": "sha256-WKVqA2n1PaPxOkCt9iC7zCv+szPd0ZzSxsBl7yUtVpI=" + }, + "nvidia-l4t-libwayland-client0": { + "name": "nvidia-l4t-libwayland-client0_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-libwayland-client0/nvidia-l4t-libwayland-client0_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-4IWdpZu1Haq8T0QW/r1OKNpsrhSOC4HmSLZYoBUEofo=" + }, + "nvidia-l4t-libwayland-cursor0": { + "name": "nvidia-l4t-libwayland-cursor0_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-libwayland-cursor0/nvidia-l4t-libwayland-cursor0_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-/rjGjiKYq883fsRYgTq2ZEPe/ugbJlzm7nkz6z16V1o=" + }, + "nvidia-l4t-libwayland-egl1": { + "name": "nvidia-l4t-libwayland-egl1_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-libwayland-egl1/nvidia-l4t-libwayland-egl1_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-LKd/K95EyiRh3WVnbMs6D8MDCCHvq/A0hxVaSQeLdY4=" + }, + "nvidia-l4t-libwayland-server0": { + "name": "nvidia-l4t-libwayland-server0_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-libwayland-server0/nvidia-l4t-libwayland-server0_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-xQ51icg+cfiTm4QaJ2Ro6S7hiVKIqBOrPFffp9xLm1k=" + }, + "nvidia-l4t-multimedia-utils": { + "name": "nvidia-l4t-multimedia-utils_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-multimedia-utils/nvidia-l4t-multimedia-utils_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-UDlRmUvoCapK+Yzvpx+tL4+HcvBbmIfAVRbfOjL7YT0=" + }, + "nvidia-l4t-multimedia": { + "name": "nvidia-l4t-multimedia_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-multimedia/nvidia-l4t-multimedia_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-AwaTWN3aNL5YhHQNScDdilFUVxoAhgdDdv4YCb5NnZE=" + }, + "nvidia-l4t-nvfancontrol": { + "name": "nvidia-l4t-nvfancontrol_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-nvfancontrol/nvidia-l4t-nvfancontrol_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-m1wZtuCQ0eoUfAT7Rmu7+020B7QhpthPPADC7DBEm4k=" + }, + "nvidia-l4t-nvml": { + "name": "nvidia-l4t-nvml_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-nvml/nvidia-l4t-nvml_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-yZJq77TM0qSx0VuxSlE1AvMLLbciSffLZG6QWUf98Ms=" + }, + "nvidia-l4t-nvpmodel-gui-tools": { + "name": "nvidia-l4t-nvpmodel-gui-tools_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-nvpmodel-gui-tools/nvidia-l4t-nvpmodel-gui-tools_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-yjWI6wbC6ItrQlt8gAszwcCRhXH2sjSV5U7OGbfh9ws=" + }, + "nvidia-l4t-nvpmodel": { + "name": "nvidia-l4t-nvpmodel_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-nvpmodel/nvidia-l4t-nvpmodel_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-vOJ+/7Rnybn1xZxnAMLxMeVWpwBGKBkEOCKbuZTXTrk=" + }, + "nvidia-l4t-nvsci": { + "name": "nvidia-l4t-nvsci_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-nvsci/nvidia-l4t-nvsci_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-gEBCIw0nSGlgoiXlJ7nYBeERcmlJoRYLwZEmxYCLN6k=" + }, + "nvidia-l4t-oem-config": { + "name": "nvidia-l4t-oem-config_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-oem-config/nvidia-l4t-oem-config_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-WL5c4JYxcy0F/TRDJpN0nmB0mTtetykoAyNwY0yyx70=" + }, + "nvidia-l4t-openwfd": { + "name": "nvidia-l4t-openwfd_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-openwfd/nvidia-l4t-openwfd_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-trpnMosrsD2dNG3Bi0047kEar8Hd0Q2CriBbYtl30Tk=" + }, + "nvidia-l4t-optee": { + "name": "nvidia-l4t-optee_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-optee/nvidia-l4t-optee_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-UwYPUq04/WRge1vIVsxgmfhOkiXsBfqEF3u0R7LmlfQ=" + }, + "nvidia-l4t-pva": { + "name": "nvidia-l4t-pva_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-pva/nvidia-l4t-pva_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-jwM3ioqqy3ZAD/Z8JGFEQDCs/8KDnscqVT4s31OdikQ=" + }, + "nvidia-l4t-tools": { + "name": "nvidia-l4t-tools_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-tools/nvidia-l4t-tools_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-NEHCXRexUT1oyyH6oloeQNxIEbWQw8gG5hp41tAp/+M=" + }, + "nvidia-l4t-vulkan-sc-dev": { + "name": "nvidia-l4t-vulkan-sc-dev_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-vulkan-sc-dev/nvidia-l4t-vulkan-sc-dev_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-JZKOROYXokKIHNb5TmLqH4uZ1O/0ZZm5GXFPsjqUNrQ=" + }, + "nvidia-l4t-vulkan-sc-samples": { + "name": "nvidia-l4t-vulkan-sc-samples_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-vulkan-sc-samples/nvidia-l4t-vulkan-sc-samples_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-NTxa0EWAmvkjAaklk7/d/AFtcAFv379sgJ/35ulOPFQ=" + }, + "nvidia-l4t-vulkan-sc-sdk": { + "name": "nvidia-l4t-vulkan-sc-sdk_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-vulkan-sc-sdk/nvidia-l4t-vulkan-sc-sdk_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-Ijr2q0fnRXo8a5dmp5os+uvJ6/NVjK67sY3fXSvORAg=" + }, + "nvidia-l4t-vulkan-sc": { + "name": "nvidia-l4t-vulkan-sc_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-vulkan-sc/nvidia-l4t-vulkan-sc_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-Z6NSRj2c668XB7SnEb6Dk6bgWyL03zopXEo2Ex5yNSA=" + }, + "nvidia-l4t-wayland": { + "name": "nvidia-l4t-wayland_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-wayland/nvidia-l4t-wayland_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-na9DvzvIS2anJToaNXhbjBSY1mutDd9pwLLYrD8sMkA=" + }, + "nvidia-l4t-weston": { + "name": "nvidia-l4t-weston_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-weston/nvidia-l4t-weston_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-w4ZZLcR9ezTBAXsqghAFTaJK188ZAhpj/CX1wTpiZ+s=" + }, + "nvidia-l4t-x11": { + "name": "nvidia-l4t-x11_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-x11/nvidia-l4t-x11_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-1eqDPTmysN0hRO8Y9RDDVgVd+0gxyvWhOaguItd6GJM=" + }, + "nvidia-l4t-xusb-firmware": { + "name": "nvidia-l4t-xusb-firmware_36.5.0-20260115194252_arm64.deb", + "url": "https://repo.download.nvidia.com/jetson/t234/pool/main/n/nvidia-l4t-xusb-firmware/nvidia-l4t-xusb-firmware_36.5.0-20260115194252_arm64.deb", + "hash": "sha256-AzILmkZ6RpapyNFCSywMcvVvB6i1OH0LPaw0Zwfi5yM=" + } + } + } + } +} From 069566b955169a8f5bac8c837dace15f061a8fa0 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Wed, 25 Feb 2026 14:38:15 -0500 Subject: [PATCH 12/30] jetson-orin-nano-super/nvidia-l4t: Add uaccess for video nodes This is the modern convention on Linux systems. Access to device nodes is mediated through ACLs being given by the login manager (not the display manager). This ensures common NixOS module configuration *just works* without needing to change the groups of greeters or compositors to include `video`. This fixes "just" using gdm and gnome (when `card0` is `nvidia-drm`). Also fix the `mknod` path at the same time. --- .../nvidia-l4t/default.nix | 30 +++++++++++++++++-- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix index 040119a..78a313f 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t/default.nix @@ -12,6 +12,7 @@ in fetchurl, autoPatchelfHook, dpkg, + systemd, # for udevadm coreutils, expat, @@ -106,8 +107,32 @@ stdenv.mkDerivation (finalAttrs: { nativeBuildInputs = [ autoPatchelfHook dpkg + systemd ]; + buildPhase = '' + args=( + # Fix style issues with the rules. + # This is used to ensure further patches are "proper". + --replace-fail '" GOTO=' '", GOTO=' + --replace-fail '" OWNER=' '", OWNER=' + --replace-fail '" GROUP=' '", GROUP=' + --replace-fail '" MODE=' '", MODE=' + --replace-fail '" KERNEL==' '", KERNEL==' + + # Patch uaccess on `video` group device nodes. + --replace-fail 'GROUP="video"' 'GROUP="video", TAG+="uaccess"' + + # replace hardcoded utils + --replace-fail "/bin/mknod" "${lib.getExe' coreutils "mknod"}" + ) + substituteInPlace etc/udev/rules.d/99-tegra-devices.rules "''${args[@]}" + + # Check this is valid, and also for style. + udevadm verify --resolve-names=late \ + etc/udev/rules.d/99-tegra-devices.rules + ''; + installPhase = '' runHook preInstall @@ -127,9 +152,8 @@ stdenv.mkDerivation (finalAttrs: { mv -t $out/share/egl/egl_external_platform.d/ usr/share/egl/egl_external_platform.d/nvidia_gbm.json mkdir -vp "$out/lib/udev/rules.d" - mv -t $out/lib/udev/rules.d etc/udev/rules.d/99-tegra-devices.rules - substituteInPlace $out/lib/udev/rules.d/99-tegra-devices.rules \ - --replace-fail "/bin/mknod" "${lib.getExe' coreutils "mknod"}" + # NOTE: uaccess tags require filenames to lexicographically sort before `73-seat-late.rules`. + mv -v etc/udev/rules.d/99-tegra-devices.rules $out/lib/udev/rules.d/70-tegra-devices.rules ( set -x From 6f004b7880ccaab4167abfbffe96cd0be627e407 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 21:57:41 -0500 Subject: [PATCH 13/30] nvidia/jetson-orin-nano-super: Rework as list of `mkIf`s Also introduce `enableStage1KernelModules` to allow end-users the option to disable the modules. This *should* generally be done for options that are lists, as those are poorly composable, and removing an element from a list in the modules system is generally hard. --- .../nvidia/jetson-orin-nano-super/default.nix | 93 +++++++++++-------- 1 file changed, 52 insertions(+), 41 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 77b6baf..bd6c1e5 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -9,53 +9,64 @@ in enableOotModules = lib.mkEnableOption "the NVIDIA Out-Of-Tree kernel modules" // { default = true; }; + enableStage1KernelModules = + lib.mkEnableOption "use of storage and necessary kernel modules in stage-1" + // { + default = true; + }; }; }; - config = lib.mkIf cfg.enable { - nixpkgs.hostPlatform = "aarch64-linux"; + config = lib.mkIf cfg.enable ( + lib.mkMerge [ + { + nixpkgs.hostPlatform = "aarch64-linux"; - boot.initrd.availableKernelModules = [ - # Enable PCIe support at boot time - "phy_tegra194_p2u" - "pcie_tegra194" - # Enable USB support for USB Boot - "xhci-tegra" - "phy-tegra-xusb" - ]; + # We can add the proprietary packages to the overlay even without enabling the + # *configuration* for proprietary packages. This leaves it up to the end-user + # to use those proprietary packages. + nixpkgs.overlays = [ + (final: super: { + kernelPackagesExtensions = (super.kernelPackagesExtensions or [ ]) ++ [ + (kFinal: _kSuper: { + nvidia-oot = kFinal.callPackage ./nvidia-oot { }; + }) + ]; + nvidia-jetson-orin-nano-super = { + nvidia-l4t = final.callPackage ./nvidia-l4t { }; + nvidia-l4t-firmware = final.callPackage ./nvidia-l4t-firmware { + inherit (final.nvidia-jetson-orin-nano-super) + nvidia-l4t + ; + }; + nvidia-l4t-kernelPackages = final.linuxPackagesFor final.nvidia-jetson-orin-nano-super.nvidia-l4t-kernel; + nvidia-l4t-kernel = final.callPackage ./nvidia-l4t-kernel { + kernelPatches = [ + final.linuxKernel.kernelPatches.bridge_stp_helper + final.linuxKernel.kernelPatches.request_key_helper + ]; + }; + }; + }) + ]; + } - boot.extraModulePackages = lib.mkMerge [ - (lib.mkIf cfg.enableOotModules [ - config.boot.kernelPackages.nvidia-oot - ]) - ]; + (lib.mkIf cfg.enableStage1KernelModules { + boot.initrd.availableKernelModules = [ + # Enable PCIe support at boot time + "phy_tegra194_p2u" + "pcie_tegra194" + # Enable USB support for USB Boot + "xhci-tegra" + "phy-tegra-xusb" + ]; + }) - # We can add the proprietary packages to the overlay even without enabling the - # *configuration* for proprietary packages. This leaves it up to the end-user - # to use those proprietary packages. - nixpkgs.overlays = [ - (final: super: { - kernelPackagesExtensions = (super.kernelPackagesExtensions or []) ++ [ - (kFinal: kSuper: { - nvidia-oot = kFinal.callPackage ./nvidia-oot { }; - }) + (lib.mkIf cfg.enableOotModules { + boot.extraModulePackages = [ + config.boot.kernelPackages.nvidia-oot ]; - nvidia-jetson-orin-nano-super = { - nvidia-l4t = final.callPackage ./nvidia-l4t { }; - nvidia-l4t-firmware = final.callPackage ./nvidia-l4t-firmware { - inherit (final.nvidia-jetson-orin-nano-super) - nvidia-l4t - ; - }; - nvidia-l4t-kernelPackages = final.linuxPackagesFor final.nvidia-jetson-orin-nano-super.nvidia-l4t-kernel; - nvidia-l4t-kernel = final.callPackage ./nvidia-l4t-kernel { - kernelPatches = [ - final.linuxKernel.kernelPatches.bridge_stp_helper - final.linuxKernel.kernelPatches.request_key_helper - ]; - }; - }; }) - ]; - }; + ] + ); } From ccfb3ed1ee962b1709491095b0c73e7b100e16fa Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 12 Feb 2026 22:17:38 -0500 Subject: [PATCH 14/30] nvidia/jetson-orin-nano-super: Add enableHardwareAcceleration --- .../nvidia/jetson-orin-nano-super/default.nix | 46 ++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index bd6c1e5..46b4c77 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -1,4 +1,9 @@ -{ config, lib, ... }: +{ + config, + lib, + pkgs, + ... +}: let cfg = config.ctrl-os.hardware.devices.nvidia-jetson-orin-nano-super; @@ -14,6 +19,10 @@ in // { default = true; }; + # Reminder device enablement modules should not set the unfree software option. + # The module *must* fail with the unfree software error. + # The user must make the informed decision about enabling unfree software. + enableHardwareAcceleration = lib.mkEnableOption "the NVIDIA proprietary graphical and ML drivers"; }; }; @@ -67,6 +76,41 @@ in config.boot.kernelPackages.nvidia-oot ]; }) + + (lib.mkIf cfg.enableHardwareAcceleration { + services.udev.packages = [ + pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t + ]; + hardware.firmware = lib.mkAfter [ + pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t-firmware + ]; + hardware.graphics.extraPackages = [ + pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t + ]; + services.xserver = { + # Use the `nvidia` driver for `tegra` kernel driver matches. + config = '' + Section "OutputClass" + Identifier "nvidia" + MatchDriver "tegra" + Driver "nvidia" + EndSection + ''; + # NOTE: videoDrivers cannot be used. + # Enabling `"nvidia"` within it uses the non-l4t NVIDIA driver. + # Instead we force the driver list to ensure only this one is used. + drivers = lib.mkForce ( + lib.singleton { + name = "nvidia"; + modules = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ]; + display = true; + deviceSection = '' + Option "AllowEmptyInitialConfiguration" "true" + ''; + } + ); + }; + }) ] ); } From a51e2e3281b0d9e18b8c200fc7583fb400ccd60c Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 09:32:16 -0500 Subject: [PATCH 15/30] nvidia/jetson-orin-nano-super: Select appropriate default kernel When users otherwise don't explicitly care, use 6.12, as `nvidia-oot` only claims to support up to 6.15, and 6.12 is the prior LTS. This only sets the kernel using `mkDefault`, so this will not affect any selection users have made for themselves. --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 46b4c77..cbba617 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -71,6 +71,10 @@ in ]; }) + { + boot.kernelPackages = lib.mkDefault pkgs.linuxPackages_6_12; + } + (lib.mkIf cfg.enableOotModules { boot.extraModulePackages = [ config.boot.kernelPackages.nvidia-oot From 89aa1006c3f6be9cefb24f16d44b0bdde75d7df1 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 10:00:06 -0500 Subject: [PATCH 16/30] nvidia/jetson-orin-nano-super: Add configuration for tegra and nvidia kernel modules --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index cbba617..6573101 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -91,6 +91,17 @@ in hardware.graphics.extraPackages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ]; + boot.kernelModules = [ + "tegra_drm" + # This *cannot* be loaded with `tegra_drm` or else it breaks. + # It will be loaded as needed. + # "nvidia_drm" + ]; + boot.extraModprobeConfig = lib.mkMerge [ + # Without `modeset`, the X11 driver will fail to work. + # This is the vendor-suggested configuration. + "options nvidia_drm modeset=1 fbdev=1" + ]; services.xserver = { # Use the `nvidia` driver for `tegra` kernel driver matches. config = '' From 699d7c3edac1c8ddacd7756d1bbecaec6b684863 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 09:59:41 -0500 Subject: [PATCH 17/30] nvidia/jetson-orin-nano-super: Add addDebugUserGroup quirk --- .../nvidia/jetson-orin-nano-super/default.nix | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 6573101..7f9c46a 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -23,6 +23,14 @@ in # The module *must* fail with the unfree software error. # The user must make the informed decision about enabling unfree software. enableHardwareAcceleration = lib.mkEnableOption "the NVIDIA proprietary graphical and ML drivers"; + quirks = { + # Enabled by default since it's cheap. + addDebugUserGroup = + lib.mkEnableOption "adding the `debug` user group, which is used in vendor udev configuration" + // { + default = true; + }; + }; }; }; @@ -81,6 +89,14 @@ in ]; }) + (lib.mkIf cfg.quirks.addDebugUserGroup { + users.groups = { + # Works around these warnings in system logs: + # /etc/udev/rules.d/99-tegra-devices.rules:00 Unknown group 'debug', ignoring. + debug = { }; + }; + }) + (lib.mkIf cfg.enableHardwareAcceleration { services.udev.packages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t From 8d0129314e1bc2c42ff25bdc42b118237e858594 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 11:48:32 -0500 Subject: [PATCH 18/30] nvidia/jetson-orin-nano-super: Add necessary links for EGL support --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 7f9c46a..7c2a13b 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -107,6 +107,10 @@ in hardware.graphics.extraPackages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ]; + environment.etc = { + "egl/egl_external_platform.d".source = "/run/opengl-driver/share/egl/egl_external_platform.d/"; + "glvnd/egl_vendor.d".source = "/run/opengl-driver/share/glvnd/egl_vendor.d"; + }; boot.kernelModules = [ "tegra_drm" # This *cannot* be loaded with `tegra_drm` or else it breaks. From a23369896e2d00f9fbd9e6c2e4d4750214c32c5a Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 10:04:33 -0500 Subject: [PATCH 19/30] nvidia/jetson-orin-nano-super: Ensure `hardware.graphics` is enabled This should end-up being accurate when the modules needing it are enabled, but just in case, make it so `/run/opengl-driver` will be automatically enabled when hardware acceleration is enabled. --- .../hardware/devices/nvidia/jetson-orin-nano-super/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 7c2a13b..d2e72e0 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -104,6 +104,7 @@ in hardware.firmware = lib.mkAfter [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t-firmware ]; + hardware.graphics.enable = true; hardware.graphics.extraPackages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ]; From 05823c045f500b12938997f918cb144e49f0fa73 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Mon, 16 Feb 2026 11:09:28 -0500 Subject: [PATCH 20/30] nvidia/jetson-orin-nano-super: Ensure kernelPackagesExtensions is available --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index d2e72e0..0df876a 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -36,6 +36,14 @@ in config = lib.mkIf cfg.enable ( lib.mkMerge [ + { + assertions = [ + { + assertion = pkgs.linuxKernel.override.__functionArgs ? kernelPackagesExtensions; + message = "The `kernelPackagesExtensions` feature was not detected on the `linuxKernel` attribute. Your Nixpkgs version may be too old."; + } + ]; + } { nixpkgs.hostPlatform = "aarch64-linux"; From c937ec12785b7cac29d13ec31ca0a44259dd1e2a Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 13:02:07 -0500 Subject: [PATCH 21/30] nvidia/jetson-orin-nano-super: Add unbindPlatformFramebuffer quirk This is used to solve the issue where the NVIDIA drivers are (still) unable to take control of the device when they are used by a DRM driver. What's funny here is that this makes the graphics driver work on mainline 6.12, whereas when using `FBDEV` in the kernel config, starting xorg would reset the board. --- .../nvidia/jetson-orin-nano-super/default.nix | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 0df876a..e6868e2 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -1,12 +1,15 @@ { config, lib, + options, pkgs, ... }: let cfg = config.ctrl-os.hardware.devices.nvidia-jetson-orin-nano-super; + # This is used to refer to an option for pretty-printing its name. + opts = options.ctrl-os.hardware.devices.nvidia-jetson-orin-nano-super; in { options = { @@ -30,6 +33,12 @@ in // { default = true; }; + unbindPlatformFramebuffer = + lib.mkEnableOption "unbinding the platform framebuffer during boot to enable use of the NVIDIA driver" + // { + default = cfg.enableHardwareAcceleration; + defaultText = "${options.enableHardwareAcceleration}"; + }; }; }; }; @@ -105,6 +114,22 @@ in }; }) + (lib.mkIf (cfg.quirks.unbindPlatformFramebuffer) { + # This can just be enabled outright. + # This won't fail if the conditions are not met. + services.udev.packages = lib.singleton ( + pkgs.writeTextFile rec { + name = "70-nvidia-unbind-simpledrm.rules"; + destination = "/etc/udev/rules.d/${name}"; + text = '' + # When udev is made aware (add|change) of the (platform) subsystem's framebuffer device (chosen:framebuffer), + # using (simple-framebuffer) as a driver, the driver is unbound, using the kernel name (effectively chosen:framebuffer). + ACTION=="add|change", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", DRIVERS=="simple-framebuffer", ATTR{driver/unbind}="%k" + ''; + } + ); + }) + (lib.mkIf cfg.enableHardwareAcceleration { services.udev.packages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t From 8dd944355a29232d52542f72eeb8771afd4d1a7e Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 10:01:05 -0500 Subject: [PATCH 22/30] nvidia/jetson-orin-nano-super: Warn on disabling unbindPlatformFramebuffer and enabling hardware acceleration This should help end-users who might be disabling that quirk to figure out issues, and leaving it accidentally enabled. --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index e6868e2..6926f4e 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -52,6 +52,11 @@ in message = "The `kernelPackagesExtensions` feature was not detected on the `linuxKernel` attribute. Your Nixpkgs version may be too old."; } ]; + warnings = + [ ] + ++ (lib.optional (!cfg.quirks.unbindPlatformFramebuffer && cfg.enableHardwareAcceleration) + "The kernel modules for hardware acceleration will not be loaded when disabling the `${opts.quirks.unbindPlatformFramebuffer}` quirk." + ); } { nixpkgs.hostPlatform = "aarch64-linux"; From d19a45b432037c7111e26c7c00848bb223714efc Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 13 Feb 2026 17:22:51 -0500 Subject: [PATCH 23/30] nvidia/jetson-orin-nano-super: Load the nvidia_drm module on unbind --- .../nvidia/jetson-orin-nano-super/default.nix | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 6926f4e..51e1c77 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -135,6 +135,19 @@ in ); }) + (lib.mkIf (cfg.quirks.unbindPlatformFramebuffer && cfg.enableHardwareAcceleration) { + services.udev.packages = lib.singleton ( + pkgs.writeTextFile rec { + name = "70-nvidia-load-nvidia-drm.rules"; + destination = "/etc/udev/rules.d/${name}"; + text = '' + # Ensure that, once the simpledrm hold is over, the `nvidia-drm` driver is loaded. + ACTION=="unbind|remove", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", RUN{builtin}+="kmod load nvidia-drm" + ''; + } + ); + }) + (lib.mkIf cfg.enableHardwareAcceleration { services.udev.packages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t From 35a1ec586808c76c7fdc7effd2b09962fb759e2f Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 10:06:08 -0500 Subject: [PATCH 24/30] nvidia/jetson-orin-nano-super: Prevent auto-loading of NVIDIA drm modules... This will be managed in the follow-up commit. Refer to it for the rationale --- .../devices/nvidia/jetson-orin-nano-super/default.nix | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 51e1c77..4aafc58 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -163,11 +163,12 @@ in "egl/egl_external_platform.d".source = "/run/opengl-driver/share/egl/egl_external_platform.d/"; "glvnd/egl_vendor.d".source = "/run/opengl-driver/share/glvnd/egl_vendor.d"; }; - boot.kernelModules = [ + boot.blacklistedKernelModules = [ + # The tegra_drm and nvidia_drm modules need to be loaded in order. + # Prevent the usual modules loading mechanisms from trying and failing. + # See 70-nvidia-unbind-simpledrm.rules for how this gets loaded. "tegra_drm" - # This *cannot* be loaded with `tegra_drm` or else it breaks. - # It will be loaded as needed. - # "nvidia_drm" + "nvidia_drm" ]; boot.extraModprobeConfig = lib.mkMerge [ # Without `modeset`, the X11 driver will fail to work. From 8860dd7d58bda966353831519df3b28f6bf4a83e Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 10:18:49 -0500 Subject: [PATCH 25/30] nvidia/jetson-orin-nano-super: Implement modules loading in a less clever way MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The clever way (trying to “react” on system-wide changes) ended-up having a race condition that could be triggered in unclear circumstances... and that race condition *was apparently why it worked*. So this rework instead implements that race condition as a feature, instead of relying on my good luck. This is still implemented as a `udev` rule as it is the easiest and most robust method to implement the required dance here: - Load `tegra-drm` such that it takes `card1` - Unbind `simpledrm` such that it frees `card0` - Load `nvidia-drm` such that it takes `card0` This, it turns out, is the secret sauce to make wayland compositors *just work* with the L4T drivers. The load order of the modules was already known to matter a lot: the `nvidia-drm` driver *must* be loaded after `tegra-drm`. And yes, the `tegra-drm` module *needs* to be loaded for it to work. The real difference compared to before is that having `card0` taken by the `nvidia-drm` driver means that, without some special proprietary sauce like in the X11 L4T driver or manual configuration, the software using DRM *should* pick the appropriate card by default. This matters when some compositors don't really expose a good way to pick a given `card` or `render` node. In an ideal world, either the `tegra-drm` would have its devices unregistered when `nvidia-drm` is loaded, or we could affect the allocation of the `minor_str` of the DRM devices so that a given device is prefered, or `nvidia-drm` could be loaded first without breaking. Alas, we're beholden to the drivers we are given. This strategy *does not* work when `simpledrm` is not in use. As of this commit, the use of the vendor kernel as-configured without `simpledrm` wouldn't work as there is nothing tying the `tegra-drm`+`nvidia-drm` driver loading to the classic `fbdev` driver. Such systems were *anyway* broken in the same way previously. --- .../nvidia/jetson-orin-nano-super/default.nix | 45 +++++++++++++------ 1 file changed, 31 insertions(+), 14 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 4aafc58..a5933af 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -129,20 +129,37 @@ in text = '' # When udev is made aware (add|change) of the (platform) subsystem's framebuffer device (chosen:framebuffer), # using (simple-framebuffer) as a driver, the driver is unbound, using the kernel name (effectively chosen:framebuffer). - ACTION=="add|change", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", DRIVERS=="simple-framebuffer", ATTR{driver/unbind}="%k" - ''; - } - ); - }) - - (lib.mkIf (cfg.quirks.unbindPlatformFramebuffer && cfg.enableHardwareAcceleration) { - services.udev.packages = lib.singleton ( - pkgs.writeTextFile rec { - name = "70-nvidia-load-nvidia-drm.rules"; - destination = "/etc/udev/rules.d/${name}"; - text = '' - # Ensure that, once the simpledrm hold is over, the `nvidia-drm` driver is loaded. - ACTION=="unbind|remove", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", RUN{builtin}+="kmod load nvidia-drm" + ACTION=="add|change", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", DRIVERS=="simple-framebuffer", ${ + if cfg.enableHardwareAcceleration then + # NOTE: This is *by design* running the unbind *after* `tegra-drm` is loaded. + # This makes: + # - `tegra-drm` take `card1` + # - `simpledrm` drop `card0` + # - `nvidia-drm` take `card0` + ''RUN+="${pkgs.writeShellScript "nvidia-simpledrm-unbind" '' + set -eux -o pipefail + unbind_path='/sys/bus/platform/devices/chosen:framebuffer/driver/unbind' + ${pkgs.kmod}/bin/modprobe tegra-drm + i=30 + # Wait until `card1` has been taken. + until test -e /dev/dri/card1; do + ${pkgs.coreutils}/bin/sleep 0.1 + ((i--)) || break + done + echo "chosen:framebuffer" > "$unbind_path" + i=30 + # Wait until `card0` is gone. + while test -e /dev/dri/card0; do + ${pkgs.coreutils}/bin/sleep 0.1 + ((i--)) || break + done + # No need to wait here. + ${pkgs.kmod}/bin/modprobe nvidia-drm + ''}"'' + else + # Just unbind if we've not enabled hardware acceleration but this quirk is on. + ''ATTR{driver/unbind}="%k"'' + } ''; } ); From bea57541866c063e3edb6b2b09f10448c6d308ae Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 12:51:39 -0500 Subject: [PATCH 26/30] nvidia/jetson-orin-nano-super: Fix evaluation with 24.05 While this is not supported to *build*, we have CI checks against 24.05, so let's make CI work. --- .../nvidia/jetson-orin-nano-super/default.nix | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index a5933af..ea3c1f2 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -169,13 +169,18 @@ in services.udev.packages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ]; - hardware.firmware = lib.mkAfter [ - pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t-firmware - ]; - hardware.graphics.enable = true; - hardware.graphics.extraPackages = [ - pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t - ]; + hardware = { + firmware = lib.mkAfter [ + pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t-firmware + ]; + # Backward compatibility to evaluate against 24.05 + "${if options.hardware ? graphics then "graphics" else "opengl"}" = { + enable = true; + extraPackages = [ + pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t + ]; + }; + }; environment.etc = { "egl/egl_external_platform.d".source = "/run/opengl-driver/share/egl/egl_external_platform.d/"; "glvnd/egl_vendor.d".source = "/run/opengl-driver/share/glvnd/egl_vendor.d"; From 2f4613d8add7469c23ec6ce4d188e775d652997a Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Fri, 20 Feb 2026 12:52:32 -0500 Subject: [PATCH 27/30] nvidia/jetson-orin-nano-super: Build vendor kernel with simpledrm Let's not rely on `fbdev`, even though *it nominally works* for the vendor kernel. Both the vendor kernel and mainline should nominally work like the other for the system integration. And that means that it should enable the `tegra-drm` and `nvidia-drm` modules with the same semantics. When using the `fbdev` setup, the `tegra-drm` and `nvidia-drm` *are* effectively loaded (despite the blacklist?) but are loaded in a way where `card0` is the `tegra-drm` device, which would be a notable difference for non-X11 graphical use-cases. --- .../nvidia-l4t-kernel/default.nix | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix index 98cfd2d..2b538ea 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/nvidia-l4t-kernel/default.nix @@ -3,6 +3,7 @@ buildLinux, fetchFromGitLab, kernelPatches, + withSimpledrm ? true, ... # This needs to forward additional `.override` args to `buildLinux`. # See `nixos/modules/system/boot/kernel.nix`. @@ -29,13 +30,17 @@ buildLinux ( # ../drivers/media/pci/intel/ipu6/../ipu-dma.c:53:17: error: implicit declaration of function 'clflush_cache_range'; did you mean 'flush_cache_range'? [-Werror=implicit-function-declaration] VIDEO_INTEL_IPU6 = lib.kernel.no; - FB_SIMPLE = lib.kernel.yes; - # SIMPLEDRM **must** be disabled for the X11 driver. - DRM_SIMPLEDRM = lib.mkForce lib.kernel.no; - # XZ compressed firmware load is not enabled if not specified. FW_LOADER_COMPRESS = lib.kernel.yes; FW_LOADER_COMPRESS_XZ = lib.kernel.yes; - }; + } + // (lib.optionalAttrs (!withSimpledrm) { + # The vendor-provided drivers are made under the assumption that fbdev is + # enabled, and simpledrm is disabled. + # This snippet is made available to make it easier for end-users to test + # their systems with the expected configuration from the vendor. + DRM_SIMPLEDRM = lib.mkForce lib.kernel.no; + FB_SIMPLE = lib.kernel.yes; + }); } ) From 37514b238b9fedcbd512c2f000bf31b7a6b35199 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Mon, 23 Feb 2026 22:04:29 -0500 Subject: [PATCH 28/30] nvidia/jetson-orin-nano-super: Add debugging option for module loading --- .../nvidia/jetson-orin-nano-super/default.nix | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index ea3c1f2..bcc3991 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -39,6 +39,11 @@ in default = cfg.enableHardwareAcceleration; defaultText = "${options.enableHardwareAcceleration}"; }; + debugModuleLoading = + lib.mkEnableOption "send debug information to the kernel log when loading the kernel module." + // { + internal = true; + }; }; }; }; @@ -137,7 +142,10 @@ in # - `simpledrm` drop `card0` # - `nvidia-drm` take `card0` ''RUN+="${pkgs.writeShellScript "nvidia-simpledrm-unbind" '' - set -eux -o pipefail + ( + set -eu -o pipefail + printf 'Loading nvidia-drm kernel module...\n\n' + set -x unbind_path='/sys/bus/platform/devices/chosen:framebuffer/driver/unbind' ${pkgs.kmod}/bin/modprobe tegra-drm i=30 @@ -155,6 +163,9 @@ in done # No need to wait here. ${pkgs.kmod}/bin/modprobe nvidia-drm + set +x + printf '... done!\n\n' + ) ${lib.optionalString cfg.quirks.debugModuleLoading ">/dev/kmsg 2>&1"} ''}"'' else # Just unbind if we've not enabled hardware acceleration but this quirk is on. From 2ef0b2917849e6110714a72d5bcbff6a1d425990 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Tue, 24 Feb 2026 10:45:39 -0500 Subject: [PATCH 29/30] nvidia/jetson-orin-nano-super: Prevent tegra-audio-graph from loading --- .../hardware/devices/nvidia/jetson-orin-nano-super/default.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index bcc3991..428bb75 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -202,6 +202,9 @@ in # See 70-nvidia-unbind-simpledrm.rules for how this gets loaded. "tegra_drm" "nvidia_drm" + # Vendor prevents this module from being loaded by default. + # The reason why is not explained. + "snd_soc_tegra_audio_graph_card" ]; boot.extraModprobeConfig = lib.mkMerge [ # Without `modeset`, the X11 driver will fail to work. From 1e011a5bf3d01066419fc19a41a1d031c72e7329 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Tue, 24 Feb 2026 21:59:16 -0500 Subject: [PATCH 30/30] nvidia/jetson-orin-nano-super: Be even less clever about loading the module MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Turns out the stack is ***very*** fussy, and there is *something* that can happen while loading the drivers, if it happens while the system is kinda busy, and in concurrence with a lot of other things. The reason this is assumed to be some race condition or similar situation is that the more things are made to go slowly, for example with sleep or by adding dynamic debug prints to the kernel, the more likely things are to work. So let's stop being clever and reactive about the environment. Instead, let's just brute-force our way to a working display output, and make the whole world wait for the driver to load. But only when the graphical target is involved. I believe this is something that the vendor is having difficulties with, as other distributions require turning of “SOC Display Hand-off” in the platform firmware for accelerated display support, and their newer Jetpack platform, for AGX Thor, also requires it for the vendor system. The fact that the vendor ships their kernel with fbdev also points toward that being true. --- .../nvidia/jetson-orin-nano-super/default.nix | 163 +++++++++++------- 1 file changed, 98 insertions(+), 65 deletions(-) diff --git a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix index 428bb75..43968a5 100644 --- a/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix +++ b/modules/hardware/devices/nvidia/jetson-orin-nano-super/default.nix @@ -8,8 +8,6 @@ let cfg = config.ctrl-os.hardware.devices.nvidia-jetson-orin-nano-super; - # This is used to refer to an option for pretty-printing its name. - opts = options.ctrl-os.hardware.devices.nvidia-jetson-orin-nano-super; in { options = { @@ -33,12 +31,6 @@ in // { default = true; }; - unbindPlatformFramebuffer = - lib.mkEnableOption "unbinding the platform framebuffer during boot to enable use of the NVIDIA driver" - // { - default = cfg.enableHardwareAcceleration; - defaultText = "${options.enableHardwareAcceleration}"; - }; debugModuleLoading = lib.mkEnableOption "send debug information to the kernel log when loading the kernel module." // { @@ -57,11 +49,6 @@ in message = "The `kernelPackagesExtensions` feature was not detected on the `linuxKernel` attribute. Your Nixpkgs version may be too old."; } ]; - warnings = - [ ] - ++ (lib.optional (!cfg.quirks.unbindPlatformFramebuffer && cfg.enableHardwareAcceleration) - "The kernel modules for hardware acceleration will not be loaded when disabling the `${opts.quirks.unbindPlatformFramebuffer}` quirk." - ); } { nixpkgs.hostPlatform = "aarch64-linux"; @@ -124,59 +111,105 @@ in }; }) - (lib.mkIf (cfg.quirks.unbindPlatformFramebuffer) { - # This can just be enabled outright. - # This won't fail if the conditions are not met. - services.udev.packages = lib.singleton ( - pkgs.writeTextFile rec { - name = "70-nvidia-unbind-simpledrm.rules"; - destination = "/etc/udev/rules.d/${name}"; - text = '' - # When udev is made aware (add|change) of the (platform) subsystem's framebuffer device (chosen:framebuffer), - # using (simple-framebuffer) as a driver, the driver is unbound, using the kernel name (effectively chosen:framebuffer). - ACTION=="add|change", SUBSYSTEM=="platform", KERNEL=="chosen:framebuffer", DRIVERS=="simple-framebuffer", ${ - if cfg.enableHardwareAcceleration then - # NOTE: This is *by design* running the unbind *after* `tegra-drm` is loaded. - # This makes: - # - `tegra-drm` take `card1` - # - `simpledrm` drop `card0` - # - `nvidia-drm` take `card0` - ''RUN+="${pkgs.writeShellScript "nvidia-simpledrm-unbind" '' - ( - set -eu -o pipefail - printf 'Loading nvidia-drm kernel module...\n\n' - set -x - unbind_path='/sys/bus/platform/devices/chosen:framebuffer/driver/unbind' - ${pkgs.kmod}/bin/modprobe tegra-drm - i=30 - # Wait until `card1` has been taken. - until test -e /dev/dri/card1; do - ${pkgs.coreutils}/bin/sleep 0.1 - ((i--)) || break - done - echo "chosen:framebuffer" > "$unbind_path" - i=30 - # Wait until `card0` is gone. - while test -e /dev/dri/card0; do - ${pkgs.coreutils}/bin/sleep 0.1 - ((i--)) || break - done - # No need to wait here. - ${pkgs.kmod}/bin/modprobe nvidia-drm - set +x - printf '... done!\n\n' - ) ${lib.optionalString cfg.quirks.debugModuleLoading ">/dev/kmsg 2>&1"} - ''}"'' - else - # Just unbind if we've not enabled hardware acceleration but this quirk is on. - ''ATTR{driver/unbind}="%k"'' - } - ''; - } - ); - }) + (lib.mkIf (cfg.enableHardwareAcceleration) { + # This service handles the weakly defined dependencies for the NVIDIA + # driver stack. + # - simpledrm must not hold the device + # - tegra-drm must be loaded before nvidia-drm + # - nvidia-drm is loaded last + # For better support of wayland compositors, this uses a trick to + # force the nvidia-drm driver to pick the `card0` name (from the + # assigned minor device number). + # This workaround will not work when “SOC Display Hand-Off” is + # disabled, or if running on a kernel with simpledrm disabled. + systemd.services.nvidia-load-modules = { + wantedBy = [ "graphical.target" ]; + before = [ + "graphical.target" + "display-manager.service" + ]; + after = [ + "multi-user.target" + "systemd-modules-load.service" + ]; + path = with pkgs; [ + kmod + coreutils + ]; + script = '' + ( + set -eu -o pipefail + printf 'Loading nvidia-drm kernel module...\n\n' + ( + # This path allows manually unbinding the simpledrm driver from the framebuffer. + # The vendor driver does not know how to do that. + unbind_path='/sys/bus/platform/devices/chosen:framebuffer/driver/unbind' + + simpledrm_card="/dev/dri/by-path/platform-chosen:framebuffer-card" + tegra_card="dev/dri/by-path/platform-13e00000.host1x-card" + nvidia_card="dev/dri/by-path/platform-13800000.display-card" + + printf "Checking nvidia-drm can take card0...\n" + if ! test -e "$unbind_path"; then + printf "WARNING: The nvidia-drm driver will be on '/dev/dri/card1'.\n" + printf "This may break some wayland compositors or other DRM software.\n" + fi + + printf "Checking if the module can be loaded...\n" + if ! modprobe --first-time --dry-run nvidia-drm; then + printf "Skipping loading nvidia-drm kernel module.\n" >&2 + # This is not a failure for this unit. + # The module might be loaded. + exit 0 + fi + + ${lib.optionalString cfg.quirks.debugModuleLoading "set -x"} + + # Load the tegra-drm driver. + # If simpledrm is loaded, this will effectively use /dev/dri/card1. + modprobe tegra-drm + + i=30 + # Wait a bit until the card shows up. + until test -e "$tegra_card"; do + sleep 0.1 + ((i--)) || break + done + + # The vendor driver stack is fussy, wait a bit more. + sleep 1 + + # Make the simpledrm driver drop the card0 identifier, if relevant. + if test -e "$unbind_path"; then + printf 'chosen:framebuffer' > "$unbind_path" + i=30 + # Wait until (effectively) card0 is free. + while test -e ; do + sleep 0.1 + ((i--)) || break + done + fi + + # The vendor driver stack is fussy, wait just a bit more again. + sleep 1 + + # Then load the driver actual driver. + modprobe nvidia-drm + ) + + printf '... done loading nvidia-drm kernel module.\n' + ) ${lib.optionalString cfg.quirks.debugModuleLoading ">/dev/kmsg 2>&1"} + ''; + serviceConfig = { + # > systemd will consider [oneshot units] to be in the state "starting" + # > until the program has terminated, so ordered dependencies will + # > wait for the program to finish before starting themselves + Type = "oneshot"; + # Never restart this unit. + Restart = "no"; + }; + }; - (lib.mkIf cfg.enableHardwareAcceleration { services.udev.packages = [ pkgs.nvidia-jetson-orin-nano-super.nvidia-l4t ];