Welcome to DRIVE Development Platform
Architecture
Software Components
NVIDIA DRIVE™ Foundation SDK/PDK
NVIDIA DRIVE™ Foundation Components
Delivery Method
NVIDIA DRIVE™ Linux SDK/PDK
NVIDIA DRIVE™ Linux RootFS Choice
NVIDIA DRIVE™ Linux Components
Delivery Method
Setting Up Your Board
Setting Up Your E3550 Platform
Front Panel
Back Panel
Cable Harness
Connecting the Platform
Device Connections
Lidar Unit Connections
Radar Unit Connections
Camera Group Pinout Connections
Setting Up the Cameras
Setting Up Your P3479 Platform
Connecting the Board
Connecting the Cable Harness
Mapping and Connecting the Camera
Mapping Connectors to Tegra
Connecting the Cameras
Default Aggregator Link Mapping
Powering On/Off the Device
Placing the Board in/out of Recovery Mode
Installation
Installing with the SDK Manager
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
Installing CUDA
Installing the CUDA Toolkit and Packages on the Host
Installing the CUDA Toolkit on the Target
Tips on Running CUDA Samples
Tips for Increasing the number of File Descriptors
CUDA Links
Camera Setup and Configuration
Setting Up the Cameras
Camera Interfaces
Mapping Connectors to Tegra
Homogeneous Camera Types
Connecting the Cameras
Camera Power Control
MCU Setup and Configuration
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 Tegra from UART
Software Setup on the Linux Host
Time Synchronization between AURIX™ and the SoC Using gPTP
FlexRay Application Demonstration
FlexRay Usage with CANOE
Flashing Basics
UFS Device Provisioning
Program bRefClkFreq
Program LUNs
Troubleshooting
Flashing AURIX
Upgrading the Firmware on Windows
Identifying the AURIX COM Port
Determining the Installed Version
Setting Up MemTool on the Windows Host
Flashing the AURIX Firmware
Flashing the AURIX Update Firmware
Flashing AURIX on Linux Xavier
Flashing the PCIe Switch and Configuration File
Figuring out the Firmware and Configuration File Version
Prerequisites for Flashing PM8533 PCIE Switch 2
Flashing PCIe Switch Configuration/Firmware from NVIDIA DRIVE™ Xavier A
Flashing Customization
Flashing the Board
Bootburn
Bootburn Command Usage
Bootburn Options
Kernel Parameter Combinations
Passing Additional Kernel Parameters
Updating the path for the targetfs
Flashing Automotive Yocto Linux built from nv-git-07 sync
Flashing Using the AURIX Console
Building the Flashing Kernel
Flashing Preprocessed Binaries
Usage
Directory Structure of Preprocessed Binaries
Flashing the Prebuilt Binaries
Flashing SKUInfo
Flashing Flow
Flashing Binaries: Offline Generation
Processed Binaries Directory Structure
Generating Binaries with an Argument File
Generating Binaries with Command Line SkuInfo
Clocks
CPU Frequency Scaling
CPU Cluster Cores Frequencies
CPU Frequency Deviations
GPU Frequency Scaling
GPU Voltage Scaling
GPU Settings
GPU Frequency Settings and Calibration Issues
Thermal Management
Tj-max(Tj-therm) Thermal Sensor
Tj-max(Tj-therm) Thermal Sensor
Tegra Internal Thermal Sensors
Determining Sensor Calibration
Viewing Various Thermal Sensor Information
External Thermal Sensors
Thermal Shutdown
TSENSE Thermal Sensor
GPU Group Thermal Sensors
AUX Group Thermal Sensors
AOTAG Sensor
External Thermal Sensor
Thermal Protection During Boot
User Space Thermal Alert
Thermal Management with Fan Control Application
Control Flow of Fan Control Application
Application Usage and Options
Usage
External Thermal Sensor
Remote Temperature Offset
Shutdown Limits
Removing External Thermal Sensor Software Support
System Programming
Compiling the Kernel (NVIDIA DRIVE Linux)
Building Cross Toolchains
Installing an Early Boot Partition
Step 1: Install on the Host System
Step 2: Set Up Connections and Perform Initial Flash
Step 3: Boot the Target
Step 4: Run Weston in Linux Rich OS (VM0)
Linux Early Boot Partition Configuration Layout
Quickboot Implementation Details
Building the Yocto Project Based Components
About the Yocto Project
Building the Yocto Project Components for DRIVE Xavier
Copying Yocto Built Products to the Release
Flashing GENIVI Instead of Ubuntu Rootfs
Setting the PATH for NVIDIA User
Probing RDC Pins
Probing RDC Pins in Quickboot
Probing RDC Pins in Kernel
Programming the Sensor Processing Engine (SPE)
Building the SPE Binaries
Code Organization
Debugging
PWR_I2C Slaves’ Access to Rich OS
SKU Framework: Customizing
About SKUInfo
Getting SKUInfo from the Kernel
Getting SKUInfo with the Quickboot API
Customizing the SKU Framework
Flashing (Host Side)
Quickboot (Target Side)
Customer Data Section in the BCT
Configuring Power on BPMP Firmware
BPMP Firmware Power Management Services
Modifying and Compiling the BPMP-FW Device Tree
Data Distribution Service
Terminology
Terminology
Domain
Domain Participant
Topic
Publisher
Subscriber
Data Writer
Data Reader
QoS Policies
Sample
IDL
Installing OpenDDS
Using Sample Applications
Running complex_idl_example test app
Complex IDL with static discovery
OpenDDS-EGL synchronization
Compile required binaries
Running dds_egl test application
Suggested Use Cases
Single VM/Intra-SoC use cases
Inter-VM and Inter-SoC Use Cases
Data Types / IDL
Discovery Model
Transport Model
Transport Selection Hierarchy
Programming Guidelines
Writing a Publisher
Writing a Subscriber
QoS for DDS entities
OpenDDS QoS Policies
Recommended Policies for Use-cases
Guidelines on integration with other Build Systems
Migration (to other DDS implementation) & Interoperability Notes
Spec Compatibility
Design Effort for Migration to Different DDS implementation
Type Representation:
Transport and Discovery mechanisms:
Choosing QoS policies:
Coding Effort
IDL compiler:
Publisher/Subscriber code:
Interoperability Issues
System Software Components and Interfaces
Network Topology in AV Configuration
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
File System Components (Target)
SSH support
Using apt-get
Installing dosfstools and ntfsprogs on Target
File System Source Code
Ethernet Jumbo Frames
Updating Firmware on 10GbE NIC
GPIO Number
Using GPIO Number
Getting GPIO Number
Accessing GPIO User Space
Exporting GPIOs through /sys Interface
Exporting with the API
CAN Driver
Enabling CAN Driver in Linux Kernel
MTTCAN as a Module
MTTCAN as a Kernel Built-in Driver
Setting up SocketCAN interface
Setting Up the CAN0 Interface
Enabling the Flexible Data Rate Mode on MTTCAN
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
UFS Device Provisioning
Program bRefClkFreq
Program LUNs
Troubleshooting
Watchdog Timer
Programming Counter Expirations at 1/3 Timeout
Enabling WDT0 from Kernel or User Space
Non-Transparent Bridging
Overview
Non-Crosslink NTB connection for Linux
Crosslink NTB connection for Linux
Realtime Clock
Automatically Setting the System Time at Boot
DRAM ECC
ECC Bits Storage
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
Uncorrectable Errors
Diagnostics
Displays
Display Server Application
Configuring displayserver
Usage Examples
Display Resolution Configuration
Adding EDID Blob
Alternative Methods
Specifying Mode in Device Tree
Using NvMedia
Connecting and Integrating the Cameras
Board Setup
Connecting Cameras
Identifying the Camera Interface Module SKU
Mapping GSML Cameras to Tegra
Camera Power Control
Building and Running the NvMedia Samples
Understanding NvMedia
Image Processing and Management
Image Capture Processing (ICP)
Image Signal Processing (ISP)
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
Process Stereo Image Pair
Convert Motion Vectors
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
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
NvMedia Sample Applications
Building and Running the NvMedia Samples
Building the NvMedia Samples
Running the Capture Driver (QNX)
Running the NvMedia Samples
Camera Module EEPROM Tools (nveeprom_flash and nveeprom_dump)
EEPROM Flash Tool (nveeprom_flash)
Flashing the Factory Section
Updating the writable section
Example: Flashing EEPROM on AR0231 Camera Modules
EEPROM Dump Tool (nveeprom_dump)
Dumping and Saving the Contents of the EEPROM
EEPROM Specification
Factory Section (Read Only)
Writable Section
Complete Specification
EGL Stream (nvm_eglstream)
Architecture
EGL Image Frame
EGLStream Producer
EGLStream Consumer
EGLStream Operation Modes
EGLStream Pipeline
EGLStream Application
Command Line Options
Required Options
Other Options
Single-Process Examples
Cross-Process Examples
Cross-Partition Examples
Vision Programming Interface (nvm_vpi)
Architecture
Running the Sample Application
Command Line Options
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 Options
Optional Command Line Options
Examples
Image Camera Capture (nvmimg_cap)
Error Detection
nvmedia: WARNING: _CaptureThreadFunc: Camera Capture Pipeline
Code Flow
Slave Capture
Suspend TO RAM Support
Suspend Sequence
Resume Sequence
Adding Suspend/Resume Support to a Camera Application
Command Line Usage
Configuration File Parameters
Configuration Set
Camera Power Control
Camera Register Control
Example Commands
Parameter Maps
Parameter Maps: E3550 Board
Parameter Maps: P3479 Board
Image Capture Calibrate (nvmimg_cc)
Command Options
Script File
Script File Configuration Parameters
I2C Device Commands
Comments
Example
Example Commands
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 Options
Image JPEG Decode (nvmimg_jpgdec)
Example Commands
Configuration Format
Output YUV Resolution
Command Options
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
Video Encode (nvmvid_enc)
Features
Architecture
Creating the Configuration File
Running the Application
Command Line Options
Examples
Configuration File Parameters
Test Cases
H.264 Encode Test Cases
H.265 Encode Test Cases
Video Demo (nvmvid_play)
Command Line Options
Required Options
Other Options
Examples
NvMediaImage from RAW Image Sensor to CUDA Consumer on dGPU (nvmipp_bayerdgpu)
Command Line Options
Example Commands
NvMediaImage to CUDA Consumer on dGPU (nvm_egldgpu)
Single-Process Operation
Cross-Process Operation
Command Line Options
Example Commands
Image OpticalFlow/StereoDisparity (nvmedia_imageofst)
Architecture
The Sample Application
Command Line Options
Examples
NvMediaImage Weave2D (nvmimg_weave2d)
Assumptions, Constraints, and Dependencies
Architecture
Error Handling
Running the Sample Application
Creating NvMedia Capture and Display Surfaces
Where Surfaces with Additional Flags Are Created
Insufficient Memory Fault
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
OpenGL ES Porting Guide
Additional Resources
Mapping OpenGL ES 2 to OpenGL ES 3
Unsupported Extensions
Unsupported Extensions with Workarounds
NV_coverage_sample
NV_depth_nonlinear
Supported Extensions
Modified Implementation Details
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
Stream-Server
Stream-Server Architecture
Location of Stream-Server and Plugins
Running Stream-Server
Configure Stream-Server
JSON File Based Configuration
Command-Line Configuration
Audio Programming
Audio Virtualization Driver
Advanced Linux Sound Architecture
Audio Stack
ASoC Virtualization Driver Architecture
SoC Platform Driver
SoC Codec Driver
SoC Machine Driver
Guest Device Tree Configuration
virt-alt-pcm
adsp_audio
Examples
Audio Playback on I2S3
Audio Recording From I2S3
Sample Rate Conversion
Asynchronous Sample Rate Conversion
Mixer Usage
Audio Ratio Detector Usage
I/O to I/O ASRC Using Hardware Ratio
Master Volume Control Usage
ADSP Audio Routing
Audio Processing Modules
Initialization
Closing
Handling Parameters
Processing Data
Interface
invfx_t
nvfx_t
nvfx_pin_state_t
nvfx_shared_state_t
nvfx_process_state_t
nvfx_mem_t
nvfx_mem_init
nvfx_buffer_t
nvfx_buffer_init
nvfx_buffer_bytes_to_end
nvfx_buffer_valid_bytes
nvfx_buffer_valid_bytes_contiguous
nvfx_buffer_bytes_free
nvfx_buffer_bytes_free_contiguous
nvfx_buffer_copy_in
nvfx_buffer_copy_out
nvfx_buffer_add_bytes
nvfx_buffer_consume_bytes
nvfx_get_sys_ts
nvfx_get_exec_ts
nvfx_get_ts_diff
nvfx_set_instance
nvfx_get_instance
Toolchain Support for Compilation and Linking
Unified ADSP Image
Build Unified ADSP Firmware
Running the Sample Plugins
Dynamic Plugin Parameter Change
APM Priority
Audio Codec Programming
Window Systems
Building and Running Samples
Building the Samples
Using NV_WINSYS when Building Graphics Samples
Running OpenGL ES Samples
Resolution Selection
Layer Selection
Antialiasing Specification
Running Samples
Program Binary Selection
Running Vulkan Samples
Wayland Window System
EGLOutput/EGLDevice Specifications That Are Used By Weston
Building Weston from Source
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
Running weston-simple-egl with ivi-shell and hmi-controller
Running weston-simple-egl with ivi-shell and ivi-controller
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
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
Manually Starting X Server
Bootloader
Boot Loader Architecture
Supported Features
TegraBoot Overview
Tegra Boot Flow
Overall Sequence
Boot ROM
Microboot 1
Microboot 2
Authentication and Validation of Binaries
Dual Authentication of Firmware
Recovery Support
SecureOS
Hypervisor-Based Flow
Virtual Machine
PartitionLoader
OSLoader
Grouping of Boot Images
Bootburn: Advanced Concepts
Boot Modes
Flashing Tools: Host Side
Flashing Tools: Target Side
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
Quickboot Sample Log
Recovery Mechanism
Introduction to Boot-Chain
Boot Chain in Parker SoC based platform
Boot Chain in Xavier SoC base platform
Overview of Chaining Approach
Advantages of Chaining Approach
Side Effect of Chaining Approach
Components not in Boot-Chain
Recovery Flow Implementation Details
Parker SoC based Platform
Xavier SoC based platform
Profiling Boot Time
Preparing the Root File System on USB Hard Drive
Understanding Security
Root of Trust and Chain of Trust
Tegra 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 PolarSSL on Parker SoC
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
GlobalPlatform 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
Building Client Applications on QNX
User Data Encryption on Linux
Cryptsetup
User Data Encryption
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
EnError! Bookmark not defined.abling JTAG Support on Secure Targets
Encrypted Key Storage in eMMC
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
Factory Secure Key Provisioning
Fuse Programming and Fuse Burning
Fuse Programming and Fuse Burning
Fuse Programming and Fuse Burning
FSKP Keys
FSKP Fuse Burning Flow
Sharing an FSKP Key with the OEM
Generating and Verifying the Self-Signed X.509 Certificate
Exporting the OEM’s RSA Private Key to a PEM File
Verifying the OEM’s Public Key with NVIDIA
System Requirements
System Circuit Requirements
Voltage Source Requirements
Temperature Requirements
The Fuse Burning Toolkit
FSKP Fuse Burn Script
Fuse Configuration File
Preparing an Encrypted and Signed Blob
Burning Fuses in the Factory
RPMB Provisioning
The Fuse Configuration File
Format of the Fuse Configuration File
About Fuse Properties
Manufacture Programmable Fuses
The SecurityMode Fuse
DebugAuthentication Fuse
ODM Field Programmable Fuses
Fuse Blob Format
The fuse_info Structure
struct fuse_node and struct fuse_info Definitions
enum FUSE Definition
Example
Security
Three-Layered Safety Supervision Framework
Overview
Key Features of 3LSS Framework
3LSS Software Stack
3LSS Communication
3LSS Framework Modules
3LSS Framework Support for Safety Diagnostic Library
Safety Diagnostic Library
3LSS Framework Support for Error Handling
Safety Errors
Using the 3LSS Framework
Objective and Behavior of 3LSS Modules
SwDiagExec
Key Features
Structuring the SDTF in Framework
Configuration Data of SwDiagExec
Safety Diagnostic ID Representation
Dynamic SDTF Registration
ErrHandlingExec
Key Features
Error Managing Stages
Safety Error ID Representation
FuSaManager
L2SS FuSaManager
L3SS FuSaManager
HeartbeatExec
Key Features
Tegra Heartbeat Packet
Heartbeat Packet Communication
CmdRespExec
Key Features
Command Response Packet
Common Design Points
3LSS Framework Availability
Configuration Information
Published Information
User Configurable Parameters
Safety Errors
Safety Diagnostics
Monitoring Time at MCU
Use Case Demonstration
Demo Setup
Configuration at MCU (L3SS) For Demo
Dummy SDL configuration at MCU
Dummy Error Handler Configuration at MCU
Input parameter values for Test commands
Configuration at Tegra SCE (L2SS) For Demo
Dummy SDL configuration at SCE
Dummy Error Handler configuration at SCE
Input parameter values for Test commands
Configuration at Tegra CCPLEX Partition (L1SS AND L0SS GOS1) For Demo
Dummy SDL configuration at CCPLEX Partition
Dummy Error Handler configuration at CCPLEX Partitions
Input parameter values for Test commands
Test Commands
User input Test Commands at MCU console
User input Test Commands at Guest OS console
Demo Use Case
Safe Startup Evaluation Demo
Add Test and Run On-demand Safety Diagnostics from Test application
Handling of Tegra Hardware Safety Error
Handling of Tegra Software Safety Error detected at Guest OS Partition
Handling of MCU Software Safety error
Add error handler to specific safety error
3LSS commands that can be used from MCU console
L3SS Porting Guide
L3SS AUTOSAR Composition
TEGRA-MCU Interface Settings
Safety Health Communication over SPI
Tegra Safety Error Signal Communication
Assumptions Of Use
MB1 Platform Configuration
Pinmux and GPIO Configuration
Prod Configuration
Pad Voltage Configuration
PMIC Configuration
Rail-Specific Parameters
Commands
Generic Format
Secure PMC Scratch Register Configurations for Boot ROM
AO Block Parameters
Commands
Security Configuration Register Configurations
Miscellaneous Configurations
Using the Update Library
Libnvupdate Framework
Update Mechanism
Dependency and Order of Update
Sequence for Updating Partitions
Using the Update Tool
Updating a Group of Images
Examples of update_sample usage
Partitions and Grouping
Updating System Partitions
Updating the RAMDisk Partition
Updating Guest Partitions
Updating the Partition Layout
Partition Update at the Second Level of Partition Table Layout
Partition Update at the Third Level of Partition Table Layout
Robot Operating System (ROS)
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
Utilities
Boot Profiling Utility
Device Tree on Tegra
Device Tree Format Overview
Device Tree Files in the BSP Framework
Example: Platform DTS
Example: Platform Intermediate DTSI
Example: Platform Common DTSI
Example: Chip DTSI
Viewing Pinmux Settings in the DTS
Kernel DTS Compilation and Flashing
Configuring Device Tree Support
Device Tree Data Format
SW-EDID
Drivers
Generating EDID Blob
USB/PCIe/SATA Device Tree Configuration
UPHY
USB
PCIe
SATA
GNU Debugger
Building GDB Client with Yocto
Debugging with gdb-multiarch Tool
Setting Up GDB Remote-Debugging Session
Linux Tracing Toolkit
Triggering System State Transition from Linux
Receiving Partition State Transition Message
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
mNAND Health and Status Utility
Building
mNAND_hs Commands
Syntax
Options
Device Paths
Example Log
mNAND Refresh Utility
Session Mode and Catch-Up Mode
Algorithm for Converging to the Refresh Schedule
Terminating or Limiting Execution in Catch-Up Mode
Recommendations for Using mnand_rfsh
Building and Running
mnand_rfsh Command Usage
Supported Options
Example Usage
Running in Session Mode
Refreshing Over Six Months
Sysfs and Procfs Entries
Boot Loader Data
Chip Information and Unique ID
GPIO Settings
Clock Settings for Tegra
Increasing the HDMI Debounce Time
tegrastats Utility
Reported Statistics
Running tegrastats
Re-Deploying tegrastats
tegrastats Options
Utilities for All Platforms
Tegra Combined UART and tcu_muxer Utility
Using tcu_muxer Tool
Usage Example on NVIDIA Native OS System
Usage example on NVIDIA Virtualization Systems
Using along with uart_muxer Tool
Finding the Number of VM Partitions
Manifest
Foundation
NVIDIA DRIVE Foundation Directory
Toolchains Directory
Linux SDK/PDK
NVIDIA DRIVE Directory
CUDA Directory
Appendix
About this Documentation
Table of Contents
Search Field
Toolbar Buttons
Table of Contents Show/Hide Button
Glossary Button
Home Button
API Button
More Button
Forward/Backward Buttons
Breadcrumbs
In-Text Menus
Body
Crypto Interface
I2C Settings
Mass Storage Partition Configuration
Mass Storage Partitions Configuration
Multipartition Architecture
Partition Overview
Xavier Native Partitions
Xavier Guest OS Partitions
Customizing the Configuration File
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
Example Virtual Partition Configuration
CFG v1
CFG v2
Example Native OS Partition Configuration
Additional Documentation
NVIDIA Documentation
Third-Party Documentation
Glossary
Legal Information
Open Source and Third-Party Software Licenses
Open Source Software Licenses
Apache License version 2.0
BSD-Style Software Distribution Licenses
Unidentified Use
Support Functions for ARM CPU
Support Functions for PPC CPU
dlmalloc License
GLFW License
GNU General Public License 2.0
mtd-utils
FreeType 6 version 2.4.12
ddccontrol version 0.2
FreeImage 3 version 3.15.1
License Information
GNU Lesser General Public License 2.1
Independent JPEG 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
Virtualization Open Source Software Licenses
BSD-Style Software Distribution Licenses
Australian Public Licence B (OZPLB)
Operating Systems and Distributed Systems Group (DiSy)
Embedded, Real-time and Operating Systems Program (ERTOS)
Apache License version 2.0
semaphore implementation
simg2img
License
RM Server Open Source Software Licenses
GNU General Public License 2.0
License Information
Bzip2
Bzip2 License
MIT License
Third-Party Licenses
Coding Technologies/AAC+
Thomson Multimedia/MP3
MPEG L.A., L.L.C./MPEG-2
MPEG-2 AAC
Fraunhofer-Gesellschaft MPEG-4 HE-AAC
Microsoft Windows Media
Microsoft PlayReady or WMDRM technology
Ogg Vorbis License
Seed32U4Bootloader
Atmel Corporation
Welcome to DRIVE Development Platform
Third-Party Licenses