Installing NVIDIA DriveOS for NVIDIA NVONLINE Users#

To install NVIDIA DriveOS™ 7.2 as an NVIDIA NVONLINE user, you can pull and run DriveOS Linux Early Access Docker images from the Artifactory container registry, then bind and flash the target system.

Binding prepares the boot, kernel, and filesystem images for your specific DRIVE AGX board variant and partition layout.
Flashing writes those images to the target over USB while the SoCs are in recovery mode, replacing the on-device software with NVIDIA DriveOS.

Together, these steps install DriveOS onto your DRIVE platform from your host PC.

For the end-to-end flashing flow for NVIDIA NVONLINE users, follow the Flashing Checklist in order for a first-time flash, or jump directly to any step.

Flashing Checklist#

Complete these steps in order:

Pre-flight checks:

Confirm Requirements for Development Environments and complete Configuring Artifactory Access for NVIDIA NVONLINE Users.
Start the Docker container:

Mount /drive_flashing and device nodes; refer to Preparing to Bind and Flash the Target System.
Recovery mode:

Understand how the target enters recovery mode before you flash; refer to Putting the Target in Recovery Mode.
Bind partitions:

Prepare flash images inside the container; refer to Binding and Flashing the Target Manually (bind step).
Flash the target:

Run bootburn.py; refer to Binding and Flashing the Target Manually (flash step).
Post-flash verification:

Accept the EULA, create a user account, and verify versions; refer to Finalizing the Installation.
(Optional) Additional packages:

Download and install CUDA, TensorRT, DriveWorks, and other SDK packages; refer to Optional: Downloading and Installing Additional NVIDIA DriveOS Packages from Artifactory.

Optionally, you can pull and run the container image ahead of time to confirm Artifactory access; refer to Pulling and Running the NVIDIA DriveOS Docker Container Image via Artifactory.

Images Available for NVIDIA DriveOS 7.2 Early Access#

Images Available for NVIDIA DriveOS 7.2 Early Access#
Image Name	Intent
`drive-agx-linux-nsr-aarch64-sdk-build-x86-earlyaccess`	Build and Flash NVIDIA DriveOS 7.2 Linux Early Access SDK

Pulling and Running the NVIDIA DriveOS Docker Container Image via Artifactory#

After configuring registry access to Artifactory, you can pull and run the NVIDIA DriveOS Docker container image on your host system. This is useful for confirming access and pre-pulling the image.

Tip

Prior to installation, you can choose to remove previously installed NVIDIA DriveOS Docker images and containers to increase space capacity.

Pull and run the NVIDIA DriveOS Docker container image by running the following command on your host system:

Note

The $ command prompt in example commands indicates running the command as a standard (non-root) user.

$ sudo docker run -it --privileged --net=host -v /dev/:/dev/ \
  -v ${WORKSPACE}:/home/nvidia/ \
  edge.urm.nvidia.com/sw-driveos-linux-docker-local/drive-agx-linux-nsr-aarch64-sdk-build-x86-earlyaccess:<version>-<build>

Where:

${WORKSPACE} is the native host directory you want to share inside the contaner.
<version>-<build> is the image version and build tag that you copied during Configuring Artifactory Access for NVIDIA NVONLINE Users.

Preparing to Bind and Flash the Target System#

To prepare to bind and flash NVIDIA DriveOS to the target system from the Docker container, perform the following steps:

Connect your NVIDIA DRIVE platform hardware to the host system.

Note

Refer to the NVIDIA DRIVE AGX Thor Developer Kit Hardware Quick Start Guide for your specific hardware.
Ensure that the DRIVE AGX is connected to the host system and that no other processes, such as TCUMuxer or Minicom, are holding a lock on /dev/ttyACM* before starting the Docker container:
- To check if a process is holding the lock, run the following command:
```
$ lsof -w /dev/ttyACM*
```
- To kill a process that is locking a specific port, run the following command:
```
$ kill -9 <pid>
```
  Where <pid> is the corresponding Process ID (PID).
Verify that the host can detect the target USB devices before flashing.

On the host system outside of the Docker container, run the following commands:
```
$ lsusb | grep -i 'Tegra On-Platform Operator'
$ lsusb | grep -i 'NVIDIA Corp. APX'
```
The Tegra On-Platform Operator device indicates that the Tegra serial endpoint is visible to the host. The NVIDIA Corp. APX device indicates that the target is in recovery mode and visible to flashing tools.

If NVIDIA Corp. APX is not listed when the target is expected to be in recovery mode, do not continue with bootburn.py. Check the USB connection, confirm that the correct debug USB Type-C port is connected, and put the target into recovery mode before retrying.

Start the NVIDIA DriveOS Docker container by running the relevant following command:

$ sudo docker run -it --privileged --net=host -v /drive_flashing:/drive_flashing \
  -v /dev/:/dev/ -v ${WORKSPACE}:/home/nvidia/ \
  edge.urm.nvidia.com/sw-driveos-linux-docker-local/drive-agx-linux-nsr-aarch64-sdk-build-x86-earlyaccess:<version>-<build>

Putting the Target in Recovery Mode#

Flashing requires the DRIVE AGX SoCs to be in recovery mode, where the host transfers boot images to the target over USB.

Automatic (recommended):

When you run bootburn.py with the -x /dev/ttyACM2 option in Binding and Flashing the Target Manually, bootburn communicates with the safety MCU (sMCU) over the specified serial port to put the SoCs in recovery mode automatically. No manual steps are required for a typical first-time flash.
Manual (if automatic recovery fails):
1. Connect to the sMCU console from the host with the following command:
```
minicom -D /dev/ttyACM2
```
2. Run the following commands:
```
tegrarecovery x1 on
```
```
tegrareset x1
```

Note

For details on recovery mode, USB interactions during flashing, and troubleshooting USB errors, refer to Device Recovery Mode in the Getting Started chapter of the NVIDIA DriveOS Linux SDK Developer Guide.

Binding and Flashing the Target#

After following Preparing to Bind and Flash the Target System, you can bind and flash the target.

Choose one of these methods and refer to the respective following section for its procedure:

Flashing the target manually
Flashing the target via DRIVEInstaller

Binding and Flashing the Target Manually#

You can bind and flash the target manually by performing the following steps:

Note

This is the default method for binding and flashing the target. Alternatively, you can use the DRIVEInstaller utility.

To bind the target, perform the following steps inside the container:

Note

The # command prompt in example commands indicates running the command as the root user.
1. Change to the following directory:
```
# cd $NV_WORKSPACE/drive-foundation
```
2. Run the relevant following bind command, based on your board variant:
  
  Important
  
  For assistance determining your board variant, refer to DRIVE Platform Supported Boards.
  - For SKU 10 boards, run the following command:
    # ./make/bind_partitions \ -b <board_variant> drive_av.linux \ -p dev_nsr \ ENABLE_THOR_U=y
    Where:
    - -b is set to the appropriate board variant from DRIVE Platform Supported Boards.
    - ENABLE_THOR_U=y is set.
  - For SKU 10/12 boards, run the following command:
    # ./make/bind_partitions \ -b <board_variant> drive_av.linux \ -p dev_nsr
    Where -b is set to the appropriate board variant from DRIVE Platform Supported Boards.
  Note
  
  If the bind command fails due to the following error:
  update-binfmts: exiting due to previous errors
  You must manually run the following apt steps on the host system outside of the container to ensure the QEMU package is properly installed:
  $ sudo apt-get remove --purge qemu-user-static $ sudo apt-get install qemu-user-static
To flash the images, perform the following steps inside the container:

Note

When flashing a new release or when you want to do a factory reset of a board, add the bootburn --init_persistent_partitions option during flashing to update the user metadata structures. This allows new data to be saved across subsequent board flashings.

To remove persistent data and do a full factory reset, add the filename=/dev/null option to the partition configuration, and then bind and reflash.
1. Change to the following directory:
```
# cd $NV_WORKSPACE/drive-foundation/tools/flashtools/bootburn/
```
2. Run the relevant following flash command, based on your board variant:
  - For SKU 10 boards, run the following command:
    # ./bootburn.py \ -b <board_variant> \ --board_config /drive/drive-foundation/platform-config/hardware/nvidia/platform/t264/automotive/automotive-platform-configs/driveos_customer_config/nv_platforms/p3960/<p3960-1n>/<p3960-1n-sw0x>/board_configs/<p3960-1n-sw0x>_thor_u.json \ -x /dev/ttyACM2
    Where:
    - -b is set to the appropriate board variant from DRIVE Platform Supported Boards.
    - --board_config specifies the file path to specific SKU 10 configs, where <p3960-1n> and <p3960-1n-sw0x> are updated based on the appropriate board variant from DRIVE Platform Supported Boards. For example, for the p3960-10-sw03 board variant:
      /drive/drive-foundation/platform-config/hardware/nvidia/platform/t264/automotive/automotive-platform-configs/driveos_customer_config/nv_platforms/p3960/p3960-10/p3960-10-sw03/board_configs/p3960-10-sw03.json
    - -x specifies the MCU serial port used to put the SoCs in recovery mode automatically. Refer to Putting the Target in Recovery Mode.
  - For SKU 10/12 boards, run the following command:
    # ./bootburn.py \ -b <board_variant> \ -x /dev/ttyACM2
    Where:
    - -b is set to the appropriate board variant from DRIVE Platform Supported Boards. Refer to Putting the Target in Recovery Mode.

Binding and Flashing the Target via DRIVEInstaller#

As an alternative to Binding and Flashing the Target Manually, you can bind and flash the target system by using the DRIVEInstaller utility. The board name is automatically detected.

DRIVEInstaller Reference#

DRIVEInstaller Required Arguments#
Argument	Description and NVIDIA DriveOS Values
`--installtype`	Specify execution mode. Valid values: `bindflash`, `install`. When setting to `install`, you must also set `--pkgpath=[PKG_PATH]`.
`--port`	Specify board safety MCU port. Example value: `/dev/ttyACM2`
`--pct_profile`	Specify the PCT domain profile. Valid value: `drive_av.linux`
`--pct_variant`	Specify the PCT variant. Valid values: `dev_nsr`, `prod_nsr`, `test_nsr`

DRIVEInstaller Optional Arguments#
Argument	Description and NVIDIA DriveOS Values
`--socfamily [SOC_FAMILY]`	Type of SOC family. Valid value: Default set to `thor`.
`--bind_opts [BIND_OPTS]`	Bind options.
`--flash_opts [FLASH_OPTS]`	Flash options.
`--pkgpath [PKG_PATH]`	Package path to be installed when using `installtype=install`.

DRIVEInstaller Example Usage#

To use the DRIVEInstaller utility to bind and flash the target:

Inside the container, change to the /drive/driveinstaller directory:
```
# cd /drive/driveinstaller
```

Run the following command with the bindflash install type:

# ./driveinstaller --installtype bindflash \
  --pct_profile "drive_av.linux" \
  --pct_variant prod_nsr \
  --socfamily thor \
  --port /dev/ttyACM2

Additional options can be passed for the binding and flashing phases by using the --bind_opts or --flash_opts arguments, respectively. The options must be passed within single- or double-quotes.

For example, to pass a debug flashing option:

--flash_opts '-d'

Troubleshooting#

If the ./driveinstaller --installtype bindflash command fails due to the following errors:
```
Bind partitions failed !

Aurix inforom parsing failed with exception

OSError: 15
```
Check to ensure you are targeting the correct --port for the board.

Optional: Downloading and Installing Additional NVIDIA DriveOS Packages from Artifactory#

The base NVIDIA DriveOS Docker image includes the core SDK. Additional packages extend your environment with CUDA, TensorRT, DriveWorks samples, and other tools. Install only the packages relevant to your workflow.

For an overview of why these packages exist and which packages to install for common development goals (CUDA, TensorRT, DriveWorks, PVA, and profiling), refer to Working with Additional NVIDIA DriveOS Packages in the Getting Started chapter of the NVIDIA DriveOS Linux SDK Developer Guide.

Host, Cross-Compilation, and Target Placement#

Additional packages are labeled by where they must be installed:

Host — Install on the x86 host or inside the Docker container (for example, driveos-cuda-repo-ubuntu2404-*-local_*_amd64.deb, NsightSystems-linux-drive-*-nda-*.deb).
Cross — Install in the container for cross-compiling applications for the target (for example, driveos-cuda-thor-nsr-repo-cross-aarch64-*, nv-tensorrt-repo-*-cross-*).
Target — Install on the flashed DRIVE AGX board (for example, driveos-cuda-thor-nsr-tegra-repo-*, nv-tensorrt-repo-*-target-*, cudnn-local-tegra-repo-*, NsightSystems-cli-linux-drive-*-arm64-*, driveworks-*-linux-nsr-aarch64-*.tar.gz).

Additional NVIDIA DriveOS packages are hosted on Artifactory and can be downloaded to the /drive_flashing directory inside the container.

To download and install additional packages:

Start the container as described in Preparing to Bind and Flash the Target System, which mounts /drive_flashing into the container.
From inside the container, export the same credentials used to log into the Artifactory repo from NVIDIA NVONLINE for the Docker container:
```
# export ARTIFACTORY_USERNAME=<your_partners_nvidia_com_email>
# export ARTIFACTORY_REF_TOKEN=<reference_token_copied_from_nvonline>
# export ARTIFACTORY_URL=https://edge.urm.nvidia.com/artifactory/sw-driveos-linux-docker-local/drive-agx-linux-nsr-aarch64-sdk-build-x86-earlyaccess/{VERSION}-{BUILD}
```
Where:
- <your_partners_nvidia_com_email> and <reference_token_copied_from_nvonline> were also used for the sudo docker login edge.urm.nvidia.com command in Configuring Artifactory Access for NVIDIA NVONLINE Users.

Optional: To only list the packages without downloading the packages, run the following command:

# curl -L -s -u $ARTIFACTORY_USERNAME:$ARTIFACTORY_REF_TOKEN "${ARTIFACTORY_URL}/files/download_files.sh" | bash -s -- --list

Download the packages by running the following command:

# curl -L -s -u $ARTIFACTORY_USERNAME:$ARTIFACTORY_REF_TOKEN "${ARTIFACTORY_URL}/files/download_files.sh" | bash -s -- --download

Install packages inside the container by using the DRIVEInstaller utility:
1. Change to the DRIVEInstaller directory:
```
# cd /drive/driveinstaller
```
2. Run DRIVEInstaller with the install install type and specify the package path:
```
# ./driveinstaller --installtype install \
  --pkgpath /drive_flashing/<filename>
```
  For example:
```
# ./driveinstaller --installtype install \
  --pkgpath /drive_flashing/driveos-cuda-repo-ubuntu2404-12-8-local_12.8.0-1_amd64.deb
```
Use DRIVEInstaller from inside the container for host and cross packages. For target-side packages and samples, follow the host/target deployment steps in the NVIDIA DriveOS Linux SDK Developer Guide (for example, Host/Target Setup and Configuration, and the DriveWorks Docker Container getting-started topic).

Optional: Downloading the NVIDIA DriveOS OSS Sources Package#

For compliance, NVIDIA DriveOS provides the following tar-bundled package that contains the upstream sources and license declarations for all third-party, open-source packages that are preinstalled and included in the official NVIDIA DriveOS Docker container images:

nv-driveos-docker-ubuntu-preinstalled-pkg-oss-src-<version>.tgz

Where <version> is the image version that you copied during Configuring Artifactory Access for NVIDIA NVONLINE Users.

Note

This tar file is intended for offline installations and reproducible analysis of the exact OSS content shipped in NVIDIA DriveOS containers.

To download the NVIDIA DriveOS OSS sources package, perform the following steps inside the container:

Start the container as described in Preparing to Bind and Flash the Target System, which shares /drive_flashing with the container.

From inside the container, export the same credentials used to log into the Artifactory repo from NVIDIA NVONLINE for the Docker container:

# export ARTIFACTORY_USERNAME=<your_partners_nvidia_com_email>
# export ARTIFACTORY_REF_TOKEN=<reference_token_copied_from_nvonline>
# export ARTIFACTORY_URL=https://edge.urm.nvidia.com/artifactory/sw-driveos-linux-docker-local/drive-agx-linux-nsr-aarch64-sdk-build-x86/{VERSION}-{BUILD}

Set the FILE_NAME environment variable to the OSS sources package name:

# FILE_NAME=nv-driveos-docker-ubuntu-preinstalled-pkg-oss-src-<version>.tgz

Download the package:

# curl -L -s -u "$ARTIFACTORY_USERNAME:$ARTIFACTORY_REF_TOKEN" \
  -o "/drive_flashing/$FILE_NAME" \
  "$ARTIFACTORY_URL/files/$FILE_NAME"

After downloading the file, change to the /drive_flashing directory:
```
# cd /drive_flashing
```
Untar the package:
```
# tar -xf $FILE_NAME
```
This creates a new directory ubuntu-preinstalled/ that includes all of the OSS sources.

Next Steps#

After successfully completing Binding and Flashing the Target, continue to Finalizing the Installation.