NVIDIA Jetson Orin - Compiling Source Code

Follow Us in

Share This Page

Facebook Twitter WhatsApp LinkedIn Email Copy Link

Close

NVIDIA®Jetson AGX Orin™
Introduction
SoM Overview Carrier Boards NVIDIA developer kit Auvidea X230D Connect Tech Forge Software Development Support
JetPack 5.0.2
Getting Started Installing JetPack Flashing the board with GUI installer JetPack Components Compiling Source Code Compiling Kernel and DTB Compiling Bootloader Flashing the Board from Cmdline Flashing Filesystem Flashing Kernel and DTB Flashing Bootloader Performance Tuning Evaluating Performance Set Values Manually Tuning Power Maximizing Performance Software Encoders For Jetson Orin Nano
Development in the Board
Getting into the Board Using Serial Console Using SSH Using Ubuntu Login Installing Packages
Emulation
Flashing commands for emulation
Supported Cameras
IMX219 Driver IMX477+J20 Driver Software Support Using GStreamer Using Libargus
Processors
HD Audio and Video Subystem Video Encoder Video Decoder JPEG Encoder and Decoder Video Image Compositor Audio Processing Engine Deep Learning Accelerator Ampere GPU Description Using CUDA Using OpenGL
Interfaces
I2C SD/eMMC Controller USB Controller
GStreamer Pipelines
Capture and Display H264 H265 VP9 MPEG4 Simultaneous Streams Compositor
Deep Learning
TensorRT Using TensorRT integrated with Tensorflow Parsing a Tensorflow model for TensorRT Parsing Caffe model for TensorRT Building TensorRT API examples Deep Learning Accelerator Software Support Deep Learning Tutorials Jetson Inference Jetson Reinforcement DeepStream SDK Usin DeepStream SDK
RidgeRun Products
GstPTZR GstCUDA GstColorTransfer GstWebRTC GstRtspSink GstInterpipe GstInference GstVPI GStreamer Daemon GstShark
RidgeRun Reference Designs
Panoramic Stitching and WebRTC Streaming
Reference Documentation
Contact Us

Learning to build the BSP and OS components enables developers to customize the software for their specific project needs.

This section will guide you through the process of building the BSP and OS components for the NVIDIA Jetson Orin. For this section you are going to need Jetpack 5.0.2 for Orin AGX installed on your host computer, we assume that you got this installed by following through our Getting Started and Installing Jetpack sections.

Assumptions

1. The build of the BSP/OS components source code will be performed by cross-compiling on a host computer running a Linux OS.
2. Make sure the following dependencies are installed on your system:

• • wget
  • lbzip2
  • build-essential
  • bc
  • zip
  • libgmp-dev
  • libmpfr-dev
  • libmpc-dev
  • vim-common # For xxd

In Debian based systems you can run the following:

sudo apt install wget lbzip2 build-essential bc zip libgmp-dev libmpfr-dev libmpc-dev vim-common

Downloading and compiling

Download the JetPack sources

You can obtain the JetPack 5.0.2 DP sources by doing the following:

1. Go to Jetson Linux Archive and download the source files for your release. Important: Consider that JetPack-5.0.2 requires L4T-35.1, JetPack-5.1.2 requires L4T-35.4.1 and so on, you can check the JetPack/L4T correlation at JetPack-Archive. For this example we use the L4T-35.1 BSP

2. Extract the .tbz2 file:

tar -xjf public_sources.tbz2

3. Extract the kernel source file:

cd Linux_for_Tegra/source/public
JETSON_SOURCES=$PWD
tar -xjf kernel_src.tbz2

This extracts the kernel source to the kernel/ subdirectory.

Kernel build instructions

Once the sources have been downloaded, perform the following steps in order to build.

Install the Toolchain

• First, download the Bootlin toolchain binaries from the NVIDIA Jetson Linux home page.
• Important same as for the BSP version, the L4T version is important, for JetPack-5.0.2 we use L4T-35.1, building L4T-35.1 with much newer compilers may cause issues, for example building JetPack-5.1.2 with l4t-gcc from L4T-36.3, causes builds to fail. For this example we download the Bootlin Toolchain gcc from L4T-35.1.

Go to the bottom of the page and click on the Bootlin Toolchain gcc option as shown in the image below:

After that, do:

mkdir $HOME/l4t-gcc
cd $HOME/l4t-gcc
tar xf <path_to_toolchain_archive>

Build the kernel

• Establish the building paths and create directories:

KERNEL_OUT=$JETSON_SOURCES/kernel_out
MODULES_OUT=$JETSON_SOURCES/modules_out
mkdir -p $KERNEL_OUT
mkdir -p $MODULES_OUT

• Use the following command to install dependencies on Ubuntu:

sudo apt install libncurses-dev

• Export environment variables:

export CROSS_COMPILE_AARCH64_PATH=$HOME/l4t-gcc
export CROSS_COMPILE_AARCH64=$HOME/l4t-gcc/bin/aarch64-buildroot-linux-gnu-

• Compile kernel:

cd $JETSON_SOURCES
./nvbuild.sh -o $KERNEL_OUT

• Install the modules

make -C $JETSON_SOURCES/kernel/kernel-5.10/ ARCH=arm64 O=$KERNEL_OUT LOCALVERSION=-tegra INSTALL_MOD_PATH=$MODULES_OUT modules_install