NVIDIA DRIVE OS SDK Development Guide
What is NVIDIA DRIVE OS?
What is NVIDIA DRIVE OS SDK?
Getting Started with NVIDIA DRIVE OS SDK
What is NVIDIA DRIVE OS PDK?
Installing DRIVE OS
Platform Software Stacks
DRIVE OS Stack
Foundation Services Stack
Additional Platform Components
Foundation Virtualization Stack
Virtualization Partition Configuration Capabilities
NvMedia Architecture
NvMedia Stack
NvMedia API Architecture
NvMedia Video Surface
NvMedia Image Surface
NvMedia APIs and Thread Safety
Additional Documentation
Foundation Services Documents
Reference Documentation
Host/Target Setup and Configuration
Setting Up Networking on the Host and Target
Configuring the Network Interface
Connecting the Target to the Host Using the Network Interface
Configuring the Private LAN to the Target Network
Configuring the DHCP and NFS Server on the Host
Networking through Comms VM
Packet Filter Settings on Comms VM
Domain Name Resolution for the Guest VMs
SSH/SCP/Telnet Access to the Guest VMs
Setting Environment Variables
Setting Variables on the Host System
Board Setup
Setting Up the E3550 Platform
Front Panel
Back Panel
Cable Harness
Connecting the Platform
Setting Up the Cameras
Powering On/Off the Device
Powering Off the Platform
Placing the Board in/out of Recovery Mode
Camera Setup and Configuration
Setting Up the Cameras
Camera Interfaces
Mapping Connectors
Homogeneous Camera Types
Connecting the Cameras
Camera Power Control
MCU Setup and Configuration
MCU Device Types
SoC to Microcontroller Communications
Camera Control Protocol
Library Usage and Configuration
CCP Sample Application Usage
Use cases
Using the MCU Console
UART Settings
MCU Console Commands
Accessing the SoC from UART
Software Setup on the Linux Host
Time Synchronization between Aurix and the SoC Using gPTP
FlexRay Application Demonstration
FlexRay Usage with CANOE
Easy CAN Usage
CAN Data from the SoC to Aurix
CAN Data from Aurix to the SoC
MCU LED Notification
OVR Issue
Flashing Basics
Flashing AURIX
Identifying the AURIX Step Version
Upgrading the Firmware
Identifying the COM Port
Determining the Installed Version
Setting Up MemTool on the Windows Host
Creating the MCU Configuration File
Flashing the AURIX UPDATE Firmware
Flashing AURIX on Xavier
Flashing the PCIe Switch and Configuration File
Switch Firmware File
Switch Configuration File
Prerequisites for Flashing PM8533 PCIE Switch 2
Flashing the PCIe Switch Configuration/Firmware from NVIDIA DRIVE Xavier A
Updating the PCIe Switch Configuration
Flashing SPI ROM Image for Marvell 88SE9345 PCIe SATA Controller
Updating the Image
Flashing Customization
Building the Flashing Kernel
Flashing Automotive Yocto Linux built from nv-git-07 sync
Flashing Using the AURIX Console
Bootburn Usage
Bootburn
Bootburn Command Usage
Bootburn Options
Kernel Parameter Combinations
Passing Additional Kernel Parameters
Updating the path for the targetfs
Using the targetfs.img file for Linux guest rootfs
Dialout Group
Configuring Ratcheting for OEM Owned Software Components
Updating the Configuration File
Generating Flashing Binaries Offline
Command Line Options
Processed Binaries Directory Structure
Generating Binaries with an Argument File
Generating Binaries with Command Line SKUInfo
Flashing Preprocessed Binaries
Usage
Directory Structure of Preprocessed Binaries
Flashing the Prebuilt Binaries
Flashing SKUInfo
Flashing Flow
Virtualization
CAN Realtime Clock
Connecting the RTC Module
Obtaining and Setting the System Time
Networking
Network Topology for AV+L PCT Config
Ethernet 100M/1G Networking
Port Roles
VLAN Configurations
gPTP/802.1AS Support on Linux
Single Pegasus: SoC-Aurix gPTP time Synchronization
Single Pegasus: SoC-SoC gPTP Time Synchronization
Dual Pegasus: SoC-SoC gPTP Time Synchronization
P3479 Network Topology
Updating Aquantia Network Interface Controller Firmware
System Software Components and Interfaces
CAN Driver
Enabling CAN Driver in Linux Kernel
MTTCAN as a Module
MTTCAN as a Kernel Built-in Driver
Setting Up CAN Loopback
Setting up SocketCAN Interface
Setting Up the CAN0 Interface
Enabling the Flexible Data Rate Mode on MTTCAN
How to Test CAN
CAN Timestamping
Setting up MTTCAN Controller Hardware filters
Programming Global Filter Configuration
Programming Standard Message ID CAN Filters
Programming Extended Message ID Filters
Kernel Modules and Limitations
Non-Transparent Bridging and PCIe Interface Communication
Overview
Non-Crosslink NTB connection for Linux
Crosslink NTB connection for Linux
DRAM Error-Correcting Code Memory on the Platform
ECC Bits Storage
Error Detection
DRAM Size Impact
DRAM Bandwidth Impact
DRAM ECC Enabled Boot on DRIVE Development Platform Pegasus
Confirming the DRAM ECC enabled boot
Software Features
Staged Scrubbing
Error Handling
Correctable Errors
Diagnostics
Crypto Interface
I2C Settings
Displays
Display Server Application
Configuring displayserver
Usage Examples
Display Resolution Configuration
Adding EDID Blob
Alternative Methods
Specifying Mode in Device Tree
NvMedia
Connecting and Integrating the Cameras
Board Setup
Connecting Cameras
Identifying the Camera Interface Module SKU
Mapping GMSL Cameras to the SoC
Camera Power Control
Building and Running the NvMedia Samples
Understanding NvMedia
Image Processing and Management
Image Capture Processing (ICP)
Image 2D
Image 2D Processing
Image Encode Processing (IEP)
Image Display Processing (IDP)
Image Processing Pipeline (IPP)
EGLStream Interoperability
NvMedia Image Sensor Control (ISC)
Video Processing
Video Decode
Supported Video Media Formats
Using the Software Video Decoders
Video Encode
Video Mixer
Layer Usage
Deinterlacing Modes
Deinterlacing Examples
Video Capture
Vision Programming
Sequence of Tasks
Algorithm APIs
Box Filter
Harris Corner Detector and Tracker
Convert Motion Vectors
Stereo Preprocess
Stereo Postprocess
FAST Corners Detector
Lucas-Kanade Feature Tracker
Kanade-Lucas-Tomasi Object Template Tracker
2D Convolution
Get Image Pyramid
Pitch Linear and Block Linear Layout Support
Supported Surface Format Packing Types
Supported Resolutions
References
NvMedia Array
NvMedia Array Attributes
NvMedia Array Attributes
Array API Functions
NvMedia Array Creation and Destroy Functions
NvMedia Tensor
Types of Tensors
Tensor Format Attributes
Tensor Allocation Attributes
Tensor API Functions
NvMedia Tensor Creation and Destroy Functions
NvSciSync
For Additional Information
Definitions
NvSciSync Functions for Specific Imaging Components
Code Examples
VPI
NvMedia Surface
Types of Surfaces
Surface Format Attributes
Surface Allocation Attributes
Surface Format Functions
Surface Allocation Functions
NvMedia Image Functions
NvMedia Video
Surface Read Code Examples
NvMedia Image Pyramid
Characteristics of a Pyramid
Creation of a Pyramid
Understanding NvMedia IPP Framework
IPP Component Types
Source Components
Capture Component
CaptureEx Component
File Reader Component
Processing Components
Control Algorithm Component
Sensor Control Components
Sink Components
Output Component
Ports
Buffer Pool
IPP Pipeline
Pipeline Manager
Component Connections
IPP Plugin
Installing the Plugin
Structure Members
Plugin API Functions
CreateFunction
DestroyFunction
ProcessExFunction
Plugin Callback
Stream Types
Input Parameters
NvMediaIPPPluginInput
Output Parameters
NvMediaIPPPluginOutputEx
IPP Internals
NvMedia IPP API Description
NvMediaIPPGetVersionInfo
NvMediaIPPManagerCreate
NvMediaIPPManagerDestroy
NvMediaIPPManagerSetTimeSource
NvMediaIPPManagerSetEventCallback
NvMediaIPPPipelineCreate
NvMediaIPPPipelineSetProperties
NvMediaIPPPipelineDestroy
NvMediaIPPPipelineStart
NvMediaIPPPipelineStop
NvMediaIPPPipelineApplyControlProperties
NvMediaIPPPipelineGetStaticProperties
NvMediaIPPPipelineGetDefaultControlsProperties
NvMediaIPPComponentCreateNew
NvMediaIPPComponentCreateImgGrp
NvMediaIPPComponentAddToPipeline
NvMediaIPPComponentAttach
NvMediaIPPComponentGetOutput
NvMediaIPPComponentGetOutputImgGrp
NvMediaIPPComponentReturnOutput
NvMediaIPPComponentReturnOutputImgGrp
NvMediaIPPComponentDestroy
NvMedia IPP Components
ICP Component
ICP EX Component
ISP Component
ALG Component
ISC Component
Output Component
File Reader Component
Environment Variables
NVMEDIA_IPP_IGNORE_VERSION
NVMEDIA_IPP_TRACE
NVMEDIA_IPP_TRACE_FILE
NVMEDIA_IPP_CA_DROP_INTERVAL
NVMEDIA_IPP_ISC_SKIP_INTERVAL
Thread Priorities
Metadata File Format
Metadata Structure
Metadata Chunk Information
Metadata Information
Metadata
Metadata Types
Image Info
Control Properties
Dynamic Properties
Embedded Line Data
LTM Information
NvMediaIPPMetadataGetSize
NvMediaIPPMetadataGet
NvMediaIPPMetadataGetAddress
IPP Pipeline Properties
Static Properties
Controls Properties
Dynamic Properties
Buffer Pools
Understanding NvMedia SIPL Framework
Architecture
Usage
Step 1: Querying Platform Configuration
Step 2: Initialize SIPL
Step 3: Start SIPL
Components
SIPL Query
Query Drivers
SIPL DeviceBlock
Camera Module Drivers
SIPL Core
Deep Learning Accelerator Programming
Sequence of Tasks
Setup
Runtime
Destroy
Supported Tensor Formats
NvMedia Sample Applications
Building and Running the NvMedia Samples
Building the NvMedia Samples
Running the NvMedia Samples
EGL Stream (nvm_eglstream)
Architecture
EGL Image Frame
EGLStream Producer
EGLStream Consumer
EGLStream Operation Modes
EGLStream Pipeline
EGLStream Application
Command Line Switches
Required Switches
Other Switches
Single-Process Examples
Cross-Process Examples
Cross-Partition Examples
EGLStream Support for Multiple Consumers/Producers
Multiple Acquire and Consumer Support
Using NvMedia EGLStream to Send an Image to Multiple Consumers
Buffer Flow with Multiple Consumers
Sending and Returning in Single Threads
Sending in a Single and Returning in Multiple Threads
Vision Programming Interface (nvm_vpi)
Architecture
Running the Sample Application
Command Line Switches
Examples
IPP Raw (nvmipp_raw)
Features
Constructing an IPP Pipeline
Threads
Slave Capture
Configuration Parameters
Running nvmipp_raw
Parameter Maps
Parameter Maps: E3550 Board
Parameter Maps: P3479 Board
Command Syntax
Required Command Line Switches
Optional Command Line Switches
Examples
Image Camera Capture (nvmimg_cap)
Error Detection
Camera Capture Pipeline
Code Flow
Slave Capture
Command Line Usage
Command Line Switches
Configuration Sets Defined in the Configuration File
Configuration Set
Camera Register Control
Parameter Maps
Parameter Maps: E3550 Board
Parameter Maps: P3479 Board
Image Capture Calibrate (nvmimg_cc)
Command Switches
Script File
Script File Commands
I2C Device Commands
Comments
Example
Example of a Command
Image Play (nvmimg_play)
Command Line Options
Required Options
Optional Options
Examples
Image Encoder (nvmimg_enc)
Architecture
Running the Sample Application
Configuration File Parameters
Command Line Options
Required Options
Other Options
Examples
Configuration File Syntax
Configuration File Parameters
Image JPEG Encode (nvmimg_jpgenc)
Example Commands
Command Line Switches
Image JPEG Decode (nvmimg_jpgdec)
Example Commands
Configuration Format
Output YUV Resolution
Command Line Switches
Image LDC (nvmimg_ldc)
Architecture
Running the Sample Application
Configuration File Parameters
General configuration parameters
Geometric Transformation Parameters
Feed Sparse Warp Map Parameters
TNR3 Parameters
Runtime Parameters
Command Line Options
Required Options
Other Options
Examples
Image 2D (nvmimg_2d)
Command Line Options
Required Options
Other Options
Configuration File Parameters
General Configuration Parameters
Video Encode (nvmvid_enc)
Features
Architecture
Creating the Configuration File
Running the Application
Command Line Switches
Examples
Configuration File Parameters
Test Cases
H.264 Encode Test Cases
H.265 Encode Test Cases
Video Demo (nvmvid_play)
Command Line Switches
Required Switches
Other Switches
Examples
RAW Data to CUDA Consumer on dGPU (nvmipp_bayerdgpu)
Command Line Switches
Example Commands
IPP File Processing (nvmipp_file)
Architecture
Command Line Options
Examples
NvMediaImage Surfaces to CUDA Consumer on dGPU (nvm_egldgpu)
Single-Process Operation
Cross-Process Operation
Command Line Options
Example Commands
Image OpticalFlow/StereoDisparity (nvmedia_imageofst)
Architecture
Command Line Options
Examples
Image 2D Processing (nvmimg_weave2d)
Assumptions, Constraints, and Dependencies
Architecture
Error Handling
Running the Sample Application
SIPL (Sensor Input Processing Library) Camera
Architecture
Running the application
Display Layout
Slave Capture
Camera Input Module (CIM) SKU Identification
Command Line Switches
Interactive Menu Options
Examples
Platform configuration: SF3324 modules in two-lane DPHY mode
Camera Commands
AR0231 (Camera Module SF3324) Using 4 Lane DPHY
AR0231 (Camera Module SF3324) Using 2 Lane DPHY
AR0231 (Camera Module SF3324) Using 4 Lane CPHY
AR0231 (Camera Module SF3324) Using 2 Lane CPHY
AR0231 (Camera Module SF3325) Using 4 Lane DPHY
AR0231 (Camera Module SF3325) Using 2 Lane DPHY
AR0231 (Camera Module SF3325) Using 4 Lane CPHY
AR0231 (Camera Module SF3325) Using 2 Lane CPHY
AR0144 (Camera Module AR0144P) Using 4 Lane DPHY
AR0144 (Camera Module AR0144P) Using 2 Lane DPHY
Constellation 2MP Using 2 Lane DPHY
Constellation 8MP Using 4 Lane DPHY
SIPL (Sensor Input Processing Library) Reprocess
Running the Application
Command Line Switches
Interactive Menu Options
Examples
Platform Configuration: SF3324 Module in Two-Lane DPHY Mode
Platform Configuration: SF3325 Module in Two-Lane DPHY Mode
Saving Metadata to a File
Creating NvMedia Capture and Display Surfaces
Where Surfaces with Additional Flags Are Created
Insufficient Memory Fault
Deep Learning Accelerator Programming Interface (nvm_dlaSample)
Architecture
Running the Sample Application
Command Line Switches
Examples
Graphics Programming
OpenGL ES Programming Tips
Programming Efficiently
State
Geometry
Shader Programs
Textures
Miscellaneous
Optimizing OpenGL ES Applications
Avoiding Memory Fragmentation
Video Memory Overview
Allocating and Freeing Video Memory
Best Practices for Video Memory Management
Graphics Driver CPU Usage
Performance Guidelines
EGLStream
EGLStream Producer
EGLStream Consumer
EGLStream Operation Modes
EGLStream Pipeline
Building a Cross-Process EGLStream Pipeline
Building a Cross-Partition EGLStream Pipeline
Building a Cross-System EGLStream Pipeline
EGLStream Support for Multiple Consumers/Producers
Multiple Acquire and Consumer Support
Using NvMedia EGLStream to Send an Image to Multiple Consumers
Buffer Flow with Multiple Consumers
Sending and Returning in Single Threads
Sending in a Single and Returning in Multiple Threads
Binary Shader Program Management
Application Management of Binary Programs
Automatic Shader Cache
Comparison and Combination
GLSLC Shader Program Compiler
Compiled Shader Program Characteristics
Libraries Loaded On-Demand
Tegra GPU Scheduling Improvements
Setting the Timeslice
Setting the Preemption Type
Runlist Interleave Frequency
Setting Parameters
Setting Parameters on Behalf of Other Applications
Building GPU Scheduling Sample Applications
Running the GPU Scheduling Sample Application
Stream-Server
Stream-Server Architecture
Location of Stream-Server and Plugins
Running Stream-Server
Configuring Stream-Server
JSON File Based Configuration
Command-Line Configuration
Building and Running Samples
Building the OpenGL ES 2.0 Samples
Using NV_WINSYS when Building Graphics Samples
Copying the OpenGL ES 2.0 Samples to the Target FS
Running the OpenGL ES 2.0 Samples
Resolution Selection
Layer Selection
Antialiasing Specification
Program Binary Selection
Display Selection
Running the DriveWorks Samples
Running Vulkan Samples
Running vkfish
Running vcube
Inter-Process Communication
Terminology
NvSciIpc Configuration Data
Adding a New Channel
Adding a New INTER_VM Channel
NvSciIpc API Usage
Prepare an NvSciIpc Endpoint for read/write
Writing to the NvSciIpc Endpoint
Reading from the NvSciIpc Endpoint
Cleaning-up an NvSciIpc Endpoint
De-Initialize NvSciIpc Library
NvStreams
Comparison with EGL
Comparison with EGL
NvSCI Libraries
Buffer Allocation
Memory Buffer Basics
Allocation Model
Types of Buffers
Memory Domain Allocation
Types of Buffer Attributes
NvSciBuf Module
Attribute Lists
Multi Datatype Attribute Lists
Reconciliation
Buffer Management
Objects
VidMem Buffers
Inter-Application
NvSciBuf API
UMD Access
NvMedia
CUDA
Streaming
Terminology
A Simple Stream
Setup
Streaming
More Complex Streams
Multiple Buffers
FIFO Mode
Mailbox Mode
Multiple Acquired Frames
Multiple Consumers
Cross-Application
Data Packets
Element Type
Element Mode
Building Block Model
Endpoints
Producer
Consumer
Multicast
IPC
Memory Sharing IPC
Memory Boundary IPC
Pool
Dynamic Pool
Queue
Stream Creation
NvSciBuf and NvSciSync Initialization
NvSciIpc Initialization
Block Creation
Block Connection
Comparison with EGL
Simple Example: Cross-Process Stream
Simple Example: Stream with Two Consumers
Event Handling
Event Query
Event Notification
Error Events
Connection Events
Resource Creation
Synchronization Resources
Synchronization Objects
Comparison with EGL
Buffer Resources
Buffer Requirements
Buffer Exchange
Comparison with EGL
Stream Attribute Query
Frame Production
Obtaining Packets
Writing Packets
Presenting Packets
Comparison with EGL
Frame Consumption
Acquiring Packets
Reading Packets
Releasing Packets
Comparison with EGL
Teardown
Block Destruction
Synchronization
Terminology
Synchronization Basics
NvSciSync Module
Inter-Application
NvSciSync Attributes
NvSciSync Attributes List
Inter-Application
Sync Management
NvSciSync Objects
Inter-Application
Cpu Wait Contexts
NvSciSyncFence Operations
Inter-Application
Timestamps
UMD Access
NvMedia
NvMedia2D-NvSciSync
CUDA
CUDA APIs
Sample Application
NvSciStream Sample Application
Building the NvSciStream Sample Application
Running the NvSciStream Sample Application
Understanding Security
Root of Trust and Chain of Trust
NVIDIA Chain of Trust
Secure Boot
Public-Key Cryptography
Secure Boot Details with PKC Protection
PKC Secure Boot Requirements
RSA Validation of the BCT and Boot Loader
ECDSA or EdDSA Authentication of the BCT and Boot Loader
RSA Secured USB Recovery Mode
ECDSA or EdDSA Secured USB Recovery Mode
Security Engine Key Slot Usage
Fuse Burning Responsibilities
Fusing a Board with a PKC Public Key Hash
Generating a PKC Key Pair Using OpenSSL
Fusing the Board with the Secure Keys
Setting Up the Platform for Secure Boot
BR BCT Signing and Hash Compression
What is a Trusted OS?
Trusted Execution Environment Secure Storage
Development Mode
Secure Storage Flow
Trusted Operating System Virtualization
Global Platform API Wrapper
Supported Data Types and Functions
Header files
Usage and Examples
Information about the GlobalPlatform APIs
TEE Secure Storage
Secure Counter
Installing the Infrastructure
Trusted and Client Application Development
Building Client Applications on Linux
User Data Encryption on Linux
Cryptsetup
User Data Encryption
Changing the Linux DTS
Data Encryption Impact on Boot Times
Encryption Algorithm
Disk Encryption Key Management
Hardware Backed Disk Encryption Key
Passphrase/Password
Building Cryptsetup with Hardware Backed Changes
Building Cryptsetup with OTE Changes
Enabling JTAG Support on Secure Targets
Encrypted Key Storage in eMMC
Linux-based Disk Encryption
Cryptsetup
User Data Encryption
Data Encryption Impact on Boot Times
Encryption Algorithm
Disk Encryption Key Management
Hardware Backed Disk Encryption Key
Building Cryptsetup with Hardware Backed Changes
Communications and Security Service
Definition of Terms
Definition of Terms
A Typical Communication Configuration
Communications Service
Multiple Virtual Machine Support
Network Perimeter Security
Infrastructure Programming
Security Service
Threat Detection
Threat Management
Example of Escalation for Denial of Service Detection and Prevention
System Exceptions
Enabling Communication and Security Services
Supported Configurations
C&S Run Files
Enabling C&S
Disabling C&S
The Configuration Tool
Configuration Tool Process Flow
Extracting the Installation Files
Launching the Configuration Tool
Using the Configuration Tool
A Tour of the Configuration Tool Interface
Flashing the Configuration File on the Target
Networking
Support Platform Boards
Virtual Networks
IP Network
10G IP Network
Network IP Assignment
Supported Virtual Machines
VLAN200 Network
Network IP Assignment
Supported Virtual Machines
CAN Over Ethernet Network
Supported Applications
Network IP Assignment
Supported Virtual Machines
Native CAN Network
Native CAN Hardware Devices
Virtualized Native CAN Driver
Supported Virtual Machines
Special Network Support
Broadcast Support
Multicast Support
Using PTP Virtualization
Configuring Virtual PTP
On QNX
On Linux
Sample ptpd-avb Commands
Accessing the Time
Security Logging
OTA Log Upload
Copying Log Files From Security
Log File Format
Log Entry Description
IP Engine
CAN and CAN Over Ethernet
Logging Module
Security Guest OS Notifications
Firewall Notifications
DPI Notifications
Linux Guest OS
Over The Air Update of Security Files
Downloads Using the Communications Virtual Machine
Supported Files
Generating Security Configuration Files
Generating TLS Security Configuration Files
Configuration Tool Appendix
Security Foundation
Detection
Threat Management
Configuration Tool Options and Values
Other Config Items: Security Services
Window Systems
Wayland Window System
EGLOutput/EGLDevice Specifications
Runtime Configuration
libdrm Support
Weston Common Options
Weston Backend Options
Multimonitor Considerations in Overlay-Compositing Mode
Weston Configuration File Location
Weston Display Configuration
Prerequisites to Starting Weston
Starting Weston
Running Weston Samples
EGLDevice
Extensions
Runtime Configuration
Conditions Requiring a Stream Surface
Implementation
Rendering to EGLDevice
Creating a Stream Surface
Cross-Process and Cross-Partition EGLStream Applications
Connecting a Surface to a Screen
Setting Up the Display with DRM
Board-to-Display Connectors
X11 Window System
Manually Starting X Server
Runtime Configuration
Using xrandr for Runtime Configuration
Querying Supported Monitors and Screen Resolutions
Obtaining Additional Help
Modifying the Static Configuration (Optional)
Using nvidia-xconfig to Configure xorg.conf
Getting Help on nvidia-xconfig
nvidia-xconfig Usage Examples
Specifying a Custom EDID for the Monitor
Setting Color Bit-Depth
Specifying Modes
Enabling Debug Mode
Multi-Display X Server Layout
Modifying xorg.conf
Enabling Screen Saver Features
Enabling EDID Polling and Native Resolution
Enabling Blending and Video Overlays
Fixing Intermittent or No Output to an HDMI Monitor
Bootloader Programming
Understanding the Boot Flow Process
BootROM
Microboot 1
Microboot 2
Authentication and Validation of Binaries
Dual Authentication of Firmware
Recovery Support
SecureOS
Hypervisor-based Flow
Virtual Machine
Partition Loader
OSLoader
Grouping of Boot Images
Flashing with Bootburn
Platform Configurations
Boot Modes
Host Side Flashing Tools
Target Side Flashing Tools
Options and Use Cases for nvdd
Flashing Scripts and Prebuilt Binaries
Flashing Flow
Configuration File in Bootburn
Boot Mode Selection
Virtualization Behavior
Rebuilding Host Side Tools
Customizing Quickboot
Compression Options
Compiling
About the Build System
Compiling Quickboot
Incrementing the Quickboot Version Number
Using Interactive Mode
Forcing Boot from the Kernel Recovery Partition
Configuring the Serial Console Baud Rate
Using I2C Controller
Appending Splash Screen/CPIO Images to the RAMdisk
Quickboot Device Tree
Clocks
Serial
QSPI
SDMMC
I2C
Field_Ratchet
Using the Bootloader Recovery Mechanism
Recovery Mechanism Boot Chains
Boot Chain Process
Boot Recovery Mechanism Flow
Scratch Register
BootROM BCT
Soft Fuse
Selecting the Active Boot Chain by BootROM
Selecting the Boot Chain by the Loader
Triggering the Recovery Mechanism Inside a Guest OS Container
Triggering the Recovery Mechanism by BootROM
Triggering Recovery Mechanism by Loader
Partition Layout
Ratcheting
Software and Hardware Ratchet Versions
Software Ratchet Version
Hardware Ratchet Version
Ratchet Constraints
Opt-in Fuse
External Factors for Fuse Burning
Software Components Protected by Ratcheting
Ratchet Levels for NVIDIA Owned Software Components
NVIDIA Ratchet Level
OEM Ratchet Level
Ratchet Level for OEM Owned Software Components
OEM Firmware Ratchet Level
Ratchet Checks
Ratchet Check for NVIDIA Owned Software Components
Ratchet Check for MB1
Ratchet Check for SC7 Firmware
Ratchet Check for MTS Firmware
Ratchet Check for Falcon Firmware
Ratchet Check for OEM Owned Software Components
Ratchet Fuse Programming
Ratcheting for MB1/SC7 and MTS Firmware
Ratcheting for Falcon Firmware
Ratchet Fuse Programming for OEM Owned Software Components
Passing Ratchet Status to Guest OSes
Lock Fuse Burning
Profiling Boot Time
Configuring MB1 Boot Configuration Table
Understanding the MB1 Boot Configuration Table
Configuring the Pinmux and GPIO
Usage
Configuring the Prod Setting
Usage
Configuring Pad Voltage Setting
Usage
Configuring the PMIC Setting
Usage
Generic Format
Configuring the Secure PMC Scratch Register for BootROM
AO Block Parameters
Configuring the Security Configuration Registers
Usage
Miscellaneous Configurations
Robot Operating System (ROS)
Organization of ROS Framework
NvROS
NvROS Architecture
EGLStream Utility Library: nvros_egl_utils
Camera Preview: nvros_cam_preview node
NvROS Image Pipeline Library: nros_img_pipeline
NvROS Camera Capture Node: nvros_cam_cap
EGL Cuda IO Library: egl_cuda_io
CUDA Processing Element: cuda_processing node
Master Controller: nvros_master node
NvROS Encoder Node
NvROS MultiEncoder Node
NvROS Video Source Node
NvROS Multi Video Source Node
NvROS Video Decoder Node
NvROS Multi Video Decoder Node
NvROS Sensors
NvROS Rectifier Node
NvROS ColorCorrection Node
NvROS Egomotion Node
NvROS Dense Optical Flow
NvROS Point Cloud Processing
NvROS Lidar Accumulation
NvROS Feature Tracking Library
NvROS Camera Blindness Detector Node
NvROS TensorRT Integration
NvROS VPI Integration
Executing NvROS Applications
Test Applications
NvROS Video Codec Nodes
NvROS Sensors Nodes
NvROS Dense Optical Flow
NvROS Point Cloud Processing
NvROS Lidar Accumulator
NvROS Rectifier Node
NvROS ColorCorrection Node
NvROS Egomotion Node
NvROS Camera Blindness Detection Node
NvROS TensorRT Integration Node
NvROS VPI Integration Node
Integrating existing or custom ROS nodes into an NvROS environment
Installing ROS
Cross Compiling ROS
Setting up the Host Environment
Preparing a Cross-Compilation Sysroot
Fixing Broken Symlinks
Downloading Sources
Invoking the Cross Compiler
Incremental Addition of ROS Packages
Mass Storage Partition Configuration
Mass Storage Partitions
Creating Partitions
Multipartition Architecture
Partition Overview
Xavier Native Partitions
Xavier Guest OS Partitions
Customizing the Configuration File
Customizing Partitions
Configuration File Entries
Setting Attributes
Aligning os_args Values and the Mass Storage Layout
Configuring GPT Devices
Flashing Partitions with a File System and Kernel Image
Managing Mass Storage Partitions in Virtualization
Partition Loader
Storage Layout
Utilities
Device Tree Structure
Device Tree Format
Device Tree Files in the BSP Framework
Example: Platform Common DTSI
Example: SoC DTSI
Viewing Pinmux Settings in the DTS
Kernel DTS Compilation and Flashing
Configuring Device Tree Support
Device Tree Data Format
SW-EDID
Configuring CPU Cores
Boot Profiler Utility
Launching the Boot Profiler Daemon
Obtaining Boot Profiler Results
Adding Profiling Points to bootprofiler
Minicom Terminal Emulation
Determining the USB Port and Serial ID
Configuring Minicom
Running Minicom
Toggling the Line Wrap Setting on Minicom
Toggling the Line Feed Setting on Minicom
Linux Tracing Toolkit
Tegra Combined UART and the tcu_muxer Utility
Using tcu_muxer
Examples
Using along with uart_muxer Tool
Finding the Number of VM Partitions
tegrastats Utility
Reported Statistics
Running tegrastats
Re-Deploying tegrastats
tegrastats Options
Manifest
Foundation
NVIDIA DRIVE Foundation Directory
Toolchains Directory
Linux sdk
NVIDIA DRIVE Directory
CUDA Directory
Open Source and Third Party
Installation Using the Command Line
Installing and Flashing Foundation and Ubuntu Linux SDK and PDK
Preparing Your Host Machine
Installing Foundation
Setting the Environment Variables
Installing the PDK Overlay
Binding the Solution
Flashing the Board
Installing Yocto Linux SDK and PDK
Preparing Your Host Machine
Installing Foundation
Setting the Environment Variables
Installing the PDK Overlay
To Install the Yocto Linux Distribution
Setting Up Access to the nv-git-07 Server
Prerequisites
Signing on to nv-git-07
Entering Account Information
Verifying the SSH Connection to Gerrit
Downloading Kernel Sources from nv-git-07
NVIDIA DRIVE OS 5.1 Open Source and Third-Party Software Licenses
License Catalog
Third Party Components in the Platform
Apache License Version 2.0
BSD-Style Software Distribution Licenses
Support Functions for ARM CPU
Support Functions for PPC CPU
Unidentified Use
Creative Commons
dlmalloc License
GLFW License
GNU General Public License 2.0
mtd-utils
mkfs
ubinize
FreeType 6 Version 2.4.12
ddccontrol Version 0.2
FreeImage 3 Version 3.15.1
GNU Lesser General Public License Version 2.1
Independent JPEG License
libjsoncpp License
libpng 1.2.6 License
Libtiff License Version 4.0.2
list License
MIT License
Open Source newlib Library
Open Source Initiative OSI - Eclipse Public License 1.0
SIL Open Font License Version 1.1
strcpy License
zlib License
NVIDIA DRIVE OS SDK Development Guide
NVIDIA DRIVE OS 5.1 Open Source and Third-Party Software Licenses