How to integrate PCN from NVIDIA Jetson on meta-tegra

Introduction to NVIDIA PCNs

A Part Change Notice (PCN) is an official notification published by NVIDIA to inform customers about changes to hardware components used in Jetson modules and carrier boards. These changes may include component substitutions, silicon revisions, memory updates, or manufacturing process adjustments that can impact system behavior, compatibility, or software requirements.

PCNs are a critical part of maintaining long-term product stability, especially in production environments where hardware consistency and software reproducibility are essential. While many PCNs are designed to be transparent, some introduce changes that require software updates, configuration adjustments, or additional validation.

For systems built using Yocto, PCNs are particularly important. Hardware changes can affect the Board Support Package (BSP), device trees, bootloader configuration, firmware, or low-level drivers. Failing to account for relevant PCNs may result in boot issues, unstable behavior, or subtle runtime problems that are difficult to diagnose.

Understanding what a PCN is, how to identify applicable notices, and how to apply them correctly in a Yocto-based workflow helps ensure reliable builds, predictable deployments, and smooth hardware transitions over the lifetime of a product.

This document focus on practical guidance for applying PCNs in Yocto.

Where to Find PCNs (Jetson Download Center)

NVIDIA publishes all official Part Change Notices (PCNs) through the Jetson Download Center. This portal is the authoritative source for Jetson hardware documentation, including PCNs, Product Change Notifications, errata, and lifecycle-related updates.

PCNs are typically organized by Jetson product family, such as Jetson Xavier, Jetson Orin, or Jetson Nano. Each PCN document includes a unique identifier, a publication date, and a detailed description of the hardware change, along with any required or recommended actions. To locate PCNs:

1. Navigate to the Jetson Download Center.
2. Search for your relevant Jetson module or platform (Orin, TX, Thor, etc).
3. Look for documents labeled Part Change Notice (PCN) or PCN Notification for information about what that PCN consists about and what modules are affected.
4. Finally, download the tbz2 file from the Overlay column.

For example, this are the available PCN's to the date for the Orin module with their respective Jetpack version.

When downloading a PCN overlay from the NVIDIA Jetson Download Center, it is important to note that the overlay package is primarily intended to be applied to a system created using NVIDIA SDK Manager. In that environment, the overlay can usually be extracted and applied directly on top of the provided BSP.

However, when working with Yocto and meta-tegra, the integration process is slightly different. meta-tegra does not rely on prebuilt BSP directories modified in place. Instead, all changes should be tracked, reproducible, and integrated as part of the build system.

For this reason, the recommended approach in meta-tegra is to integrate PCN overlays as patches. This allows the changes introduced by the PCN to be clearly documented, version-controlled, and automatically applied during the Yocto build process.

In the following steps, we will download the .tbz overlay from the Overlay column in the Jetson Download Center and use it to generate the corresponding patch suitable for integration into a meta-tegra-based Yocto environment.

Before generating a patch from a PCN overlay, you need a clean reference source tree to compare against. In the context of Jetson/Yocto development with meta-tegra, the “clean sources” are provided by NVIDIA as the Jetson_Linux package.

How to Apply a PCN in Yocto (meta-tegra)

Step 1 - Download the clean Jetson_Linux sources

Before generating a patch from a PCN overlay, you need a clean reference source tree to compare against. In the context of Jetson/Yocto development with meta-tegra, the “clean sources” are provided by NVIDIA as the Jetson_Linux package.

Example:

https://developer.download.nvidia.com/embedded/L4T/r36_Release_v4.4/release/Jetson_Linux_R36.4.4_aarch64.tbz2

In this URL, Jetson_Linux_R36.4.4_aarch64.tbz2 contains the original, unmodified kernel and related components corresponding to the R36.4.4 release. We will use this directory as our baseline to generate the patch.

Here is a table with the URL for the most recent Jetson_Linux release for ease reference:

JetPack Version	L4T Version	Jetson_Linux Source Package
JetPack 6.0.2	R36.4.4	https://developer.download.nvidia.com/embedded/L4T/r36_Release_v4.4/release/Jetson_Linux_R36.4.4_aarch64.tbz2
JetPack 6.0.1	R36.4.3	https://developer.download.nvidia.com/embedded/L4T/r36_Release_v4.3/release/Jetson_Linux_R36.4.3_aarch64.tbz2
JetPack 5.1.2	R35.4.1	https://developer.download.nvidia.com/embedded/L4T/r35_Release_v4.1/release/Jetson_Linux_R35.4.1_aarch64.tbz2
JetPack 5.1.1	R35.3.1	https://developer.download.nvidia.com/embedded/L4T/r35_Release_v3.1/release/Jetson_Linux_R35.3.1_aarch64.tbz2

Once the appropriate Jetson_Linux package has been downloaded, extract it using:

mkdir -p ~/PCN_tutorial/Clean_JL_sources
tar -xjf Jetson_Linux_R36.4.4_aarch64.tbz2 -C ~/PCN_tutorial/Clean_JL_sources

After extraction, the directory structure should look similar to:

~/PCN_tutorial/Clean_JL_sources/Jetson_Linux/

This Jetson_Linux directory represents the clean, unmodified NVIDIA sources and will be used as the reference tree when applying the PCN overlay and generating the corresponding patch for integration into a Yocto/meta-tegra environment.

Step 2 – Uncompress the PCN Overlay .tbz File

Download the PCN overlay from the Overlay column in the NVIDIA Jetson Download Center. The overlay is typically provided as a .tbz archive.

Create a working directory to extract the overlay:

mkdir -p ~/PCN_tutorial/PCN_overlay

Extract the overlay archive:

tar -xjf <PCN_overlay>.tbz -C ~/PCN_tutorial/PCN_overlay

After extraction, the overlay directory will contain a structure similar to a standard Jetson_Linux tree. These files represent the changes introduced by the PCN and are intended to be applied on top of the original NVIDIA sources.

This extracted overlay will be compared against the clean Jetson_Linux sources in the next step to generate the patch for integration into a Yocto/meta-tegra environment.

Step 3 – Generate the Patch from the PCN Overlay

Once both the clean Jetson_Linux sources and the PCN overlay have been extracted, the next step is to generate a patch by comparing both trees.

At this point, you should have the following directories:

• Clean sources (baseline): ~/PCN_tutorial/Clean_JL_sources/Jetson_Linux
• PCN overlay (modified files): ~/PCN_tutorial/PCN_overlay/Jetson_Linux

The goal is to capture only the changes introduced by the PCN in a single patch file that can later be applied within a Yocto/meta-tegra layer.

From any directory, run:

diff -ruN ~/PCN_tutorial/Clean_JL_sources/Jetson_Linux \
          ~/PCN_tutorial/PCN_overlay/Jetson_Linux \
          > ~/PCN_tutorial/pcn_overlay.patch

The resulting file:

~/PCN_tutorial/pcn_overlay.patch

Step 4 – Integrate the PCN Patch Using a .bbappend

In meta-tegra, the recipe responsible for downloading, unpacking, and preparing the Jetson_Linux directory is tegra-binaries.

This recipe fetches the official NVIDIA L4T binaries and sources and applies any required modifications during the Yocto build.

For this reason, PCN patches that modify files under Jetson_Linux must be applied via a bbappend to tegra-binaries.

Create the .bbappend in your custom layer

In your custom Yocto layer, create the following file:

meta-yourlayer/
└── recipes-bsp/
    └── tegra-binaries/
        ├── tegra-binaries_%.bbappend
        └── files/
            └── pcn_overlay.patch

Copy the previously generated patch into the files/ directory:

cp ~/PCN_tutorial/pcn_overlay.patch \
   meta-yourlayer/recipes-bsp/tegra-binaries/files/

Add the patch to tegra-binaries

Create/Edit tegra-binaries_%.bbappend and add:

FILESEXTRAPATHS:prepend := "${THISDIR}/files:"

SRC_URI += "file://pcn_overlay.patch"

That’s all that is required.

During the build, Yocto will:

1. Download the official NVIDIA Jetson_Linux package
2. Extract it into the work directory
3. Apply pcn_overlay.patch
4. Continue the build using the PCN-updated sources