Advanced Flashing Features#

Flashing Both QSPI and Mass Storage with initrd Flashing Utility#

Use l4t_initrd_flash.sh to flash a Jetson device. You can flash with initrd (initial RAM disk) to both internal media and external media connected to a Jetson device. The procedure uses initrd and USB device mode.

You can find tools and instructions for flashing with initrd in the directory /Linux_for_Tegra/tools/kernel_flash/. For more detailed information, see README_initrd_flash.txt in the same directory.

README_initrd_flash.txt contains examples of several workflows that flash with initrd:

  • Flashing internal storage devices

  • Flashing external storage devices such as NVMe SSD and USB drives

  • Enabling A/B rootfs on external storage devices

  • Enabling disk encryption on external storage devices

  • Flashing individual partitions

  • Flashing fused Jetson devices

  • Flashing a Massflash blob to normal and fused Jetson devices

  • Generating separate images for external and internal storage devices, then flashing the combined images

Basic Flashing Script Usage#

Display the current usage information for l4t_initrd_flash.sh by running l4t_initrd_flash.sh -h, using the script included in the release. The syntax is as follows:

$ sudo ./l4t_initrd_flash.sh [<options>] <board> <rootdev>
  • options is one or more command-line options. No options are required. For more information, see Flashing Script Usage (l4t_initrd_flash.sh).

  • <board> specifies the configuration to be applied to the device to be flashed. Values are listed in the Jetson Modules and Configurations table. l4t_initrd_flash.sh gets the configuration from a configuration file named <board>.conf. <board>.conf specifies the location of a partition layout file which specifies what storage devices are flashed on the Jetson target. For more detailed explanation of <board>.conf, see Generating a Flash Image and Flashing Later.

  • <rootdev> specifies the type of device to be used as the root file system. For most use cases, you should use the value internal to specify a local storage device (NVMe SSD or UFS) as the root file system.

Basic Flashing Procedures#

This section describes common procedures for flashing one or more target devices.

Installing the Flash Requirements#

  • Run the following command:

    $ sudo tools/l4t_flash_prerequisites.sh
    

Flashing the Target Device#

  1. Put the target device into Force Recovery Mode.

    1. Power on the carrier board and hold down the RECOVERY button.

    2. Press the RESET button.

  2. Run the tools/kernel_flash/l4t_initrd_flash.sh script that is in the top-level directory of BSP for this release. The command line must specify the target board (for example, jetson-agx-thor-devkit) and the root device:

    $ sudo ./l4t_initrd_flash.sh <board> <rootdev>
    

    For example, run the script like this:

    $ sudo ./l4t_initrd_flash.sh <board> internal
    
  3. After flashing completes, the Jetson Thor device boots to an initrd prompt instead of booting automatically into Linux. To boot into the Linux prompt, reset the device by performing one of the following actions:

    • On the host, run the following command:

      $ ./tools/board_automation/boardctl -t thor-jetson-devkit reset
      
    • On the carrier board, press the RESET button.

Note

The Jetson Orin device reboots automatically once flashing completes.

Common Initrd Flashing Examples#

You can flash Jetson devices for different storage and root file system configurations by using the following commands:

Note

The following examples apply to both Jetson Orin and Jetson Thor devices. Use the command that matches your device.

  • Flashing for the default case:

    $ sudo ./l4t_initrd_flash.sh jetson-agx-thor-devkit internal
    $ sudo ./l4t_initrd_flash.sh jetson-agx-orin-devkit internal
    $ sudo ./l4t_initrd_flash.sh jetson-orin-nano-devkit internal
    
  • Flashing with rootfs A/B enabled:

    $ sudo ROOTFS_AB=1 ./l4t_initrd_flash.sh jetson-agx-thor-devkit internal
    $ sudo ROOTFS_AB=1 ./l4t_initrd_flash.sh jetson-agx-orin-devkit internal
    $ sudo ROOTFS_AB=1 ./l4t_initrd_flash.sh jetson-orin-nano-devkit internal
    
  • Flashing with disk encryption enabled:

    $ sudo ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-agx-thor-devkit internal
    $ sudo ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-agx-orin-devkit internal
    $ sudo ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-orin-nano-devkit internal
    

    Note

    The -i ./ekb.key option specifies the disk encryption key. Refer to How to Create an Encrypted Rootfs on the Host in Disk Encryption.

  • Flashing with both rootfs A/B and disk encryption enabled:

    $ sudo ROOTFS_AB=1 ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-agx-thor-devkit internal
    $ sudo ROOTFS_AB=1 ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-agx-orin-devkit internal
    $ sudo ROOTFS_AB=1 ROOTFS_ENC=1 ./l4t_initrd_flash.sh -i ./ekb.key jetson-orin-nano-devkit internal
    

For flashing commands for other Jetson devices, refer to Flash Jetson Developer Kits.

Note

By default, the board configuration and the partition layout support external media with a storage capacity of at least 234 GB for Jetson Thor devices or 57 GB for Jetson Orin devices. To accommodate external media that have different storage capacities, see the -T option of the EXTOPTIONS environment variable in Flashing Script Usage (l4t_initrd_flash.sh).

Generating a Flash Image and Flashing Later#

The board configuration file (<board>.conf) is a bash script that defines several bash variables. These variables specify the Boot Configuration Table (BCT), Device Tree Blob (DTB), kernel, configuration files, firmware, and partition layout to be used by l4t_initrd_flash.sh.

The board configuration file specifies partition configuration files that describe the storage devices that are flashed by the flashing tool and the partition layouts on those storage devices. It uses the following variables:

  • EMMC_CFG: Specifies the partition configuration file that describes both the internal storage device and the partition layout for the internal storage device. This variable is required.

  • EXTERNAL_PT_LAYOUT: Specifies the default partition configuration file that describes only the partition layout for the external storage device. The external storage device to be flashed is specified in the EXTERNAL_DEVICE variable or the --external-device option. This variable is optional; you can provide the information by using the -c option instead.

  • EXTERNAL_DEVICE: Specifies the default external storage device to be flashed for the EXTERNAL_PT_LAYOUT variable. This variable is optional.

For more information about the format of the partition configuration file, see Partition Configuration.

Generating a Flash Image with a Device Connected#

Typically, NVIDIA-provided board configurations rely on values retrieved from EEPROM and the chip to define these bash variables. To generate a flash image for later flashing:

  1. Place the Jetson target into recovery mode.

  2. Use this command to retrieve the EEPROM and chip information from the board, and to subsequently generate a flash image:

    $ sudo ./l4t_initrd_flash.sh --no-flash <board> internal
    

Generating a Flash Image Without a Device Connected (Offline Mode)#

When the Jetson target in recovery mode is unavailable, you can still generate a flash image by using EEPROM and chip values obtained manually through environment variables. For example:

$ sudo BOARDSKU=0000 FAB=500 BOARDREV=500 CHIP_SKU=D0 RAMCODE_ID=0 FUSELEVEL=fuselevel_production ./l4t_initrd_flash.sh --no-flash jetson-agx-thor-devkit internal

Such information is usually available on the Jetson target specification sheet. Alternatively, refer to Getting Board Specification and Fuse Information to get the board specification variables if you have physical access to the Jetson target.

Flashing the Pre-generated Images#

After generating the flash image, you can proceed with flashing at a later time using this command:

$ sudo ./l4t_initrd_flash.sh --flash-only <board> internal

Flashing Multiple Jetson Devices for Mass Production#

NVIDIA provides tools and instructions to efficiently flash Jetson devices in a factory environment. The following two sections introduce two solutions: flashing multiple Jetson Devices from a host machine directly or using backup and restoring. You can choose either of them.

Note

Using backup and restoring to flash multiple Jetson devices requires at least one Jetson device has been flashed.

Flashing Multiple Jetson Devices From the Host Machine#

To flash to multiple Jetson devices with this tool, generate the massflash package using the --no-flash and --massflash <x> options, where <x> is the highest possible number of devices that will be concurrently flashed.

Both online mode and offline mode are supported. In the following example, the offline mode is used to create a flashing environment that can concurrently flash five devices:

$ sudo BOARDID=<boardid> FAB=<fab> BOARDSKU=<boardsku> BOARDREV=<boardrev> CHIP_SKU="00:00:00:xx"  ./l4t_initrd_flash.sh --no-flash --massflash 5 <board> internal

Refer to Generating a Flash Image Without a Device Connected (Offline Mode) for how to get the board information.

  1. Connect the five Jetson devices to the flashing hosts.

  2. Ensure that the devices have the same hardware revision.

  3. Place all connected Jetson devices into RCM mode.

  4. Run the following command:

    $ sudo ./l4t_initrd_flash.sh --flash-only --massflash 5 <board> internal
    # Optionally add --showlogs to show all logs
    

Note

The actual number of connected devices can be less than the maximum number of devices the package can support.

When you use this tool, remember the following tips:

  • Use ionice to make the flash process the highest I/O priority in the system:

    $ sudo ionice -c 1 -n 0 ./l4t_initrd_flash.sh --flash-only --massflash 5 <board> internal
    
  • If mass flashing with UEFI secure boot enabled, refer to Workflow 8 in <Linux_for_Tegra>/tools/kernel_flash/README_initrd_flash.txt. For example, to mass flash with UEFI payload encryption:

    $ sudo ./l4t_initrd_flash.sh --flash-only --massflash 5 --uefi-keys uefi_keys.conf --uefi-enc uefi_payload_encryption.key <board> internal
    

Backing Up and Restoring Multiple Jetson Devices#

NVIDIA provides tools for creating a backup image of a Jetson device and restoring the device from a backup image.

The tools for backing up and restoring a Jetson device are in this directory in the BSP:

/Linux_for_Tegra/tools/backup-restore/

Instructions for backing up and restoring one device or multiple devices are in the file README_backup_restore.txt in the same directory.

The time it takes to back up or restore a partition depends on the size of the partition.

Flashing a Specific Partition#

You can flash a specific partition instead of flashing the whole device by using the command-line option -k.

  • Prepare the workspace with necessary files (only once):

    $ sudo ./l4t_initrd_flash.sh --no-flash <board> <rootdev>
    
  • Enter the following command:

    $ sudo ./l4t_initrd_flash.sh -k <partition_name> <board> <rootdev>
    

    In this command,

Examples#

Prepare the workspace with necessary files:

$ sudo ./l4t_initrd_flash.sh --no-flash jetson-agx-thor-devkit internal

To flash A_MB1_BCT on a Jetson Thor device using a predefined list of configuration files:

$ sudo ./l4t_initrd_flash.sh -k A_MB1_BCT jetson-agx-thor-devkit internal

To flash only QSPI on a Jetson Thor device:

$ sudo ./l4t_initrd_flash.sh --qspi-only jetson-agx-thor-devkit internal

To flash only NVMe SSD:

$ sudo ./l4t_initrd_flash.sh --external-only --external-device nvme0n1 -c tools/kernel_flash/flash_l4t_t264_nvme.xml <board> <rootdev>

To flash APP partition in the NVMe:

$ sudo ./l4t_initrd_flash.sh --external-only -k APP --external-device nvme0n1 -c tools/kernel_flash/flash_l4t_t264_nvme.xml <board> <rootdev>

Configuring a NFS-based Mass Storage#

Flashing for a Network File System as a Root File System#

  1. Put the device into recovery mode: Power the carrier board on, press and hold the RECOVERY button, and then press the RESET button.

  2. Enter the following command:

    $ sudo EXTOPTIONS="-N <ip_addr>:<root_path>" ./l4t_initrd_flash.sh --external-device <storage-device> -c <external-board-config> -p "-N <ip_addr>:<root_path>" <board> eth0
    

    In this command,

    • <storage-device> is the external storage device that is attached to the Jetson device. For example, --external-device nvme0n1p1 specifies an NVMe SSD attached to the Jetson device.

    • <external-board-config> is the external board configuration file for the storage device attached to the Jetson device. For example, -c tools/kernel_flash/flash_l4t_t264_nvme.xml is the file for an NVMe SSD attached to Jetson Thor.

    • <ip_addr> is the IP address of the host system.

    • <root_path> is the path to the NFS root file system.

    • <board> is the configuration of the target device as specified in the Jetson Modules and Configurations table in Quick Start.

    The command flashes Bootloader and a file system image with a /boot directory only to use the network file system at <ip_addr>:/<root_path> as the root file system at boot time.

Booting From a Network File System as a Root File System#

This section assumes that users understand how to set up their network and the configuration requirements.

The UEFI bootloader on Jetson can boot from a PXE Boot Server without using a special flashing configuration.

The PXE Boot Server comprises the following components:

  • DHCP server: provides the IP address information and the location of the initial application (NBP).

  • TFTP server: hosts the NBP and other initial files (kernel, grub.cfg, initrd, and so on).

  • NFS server: exposes the root file system for the boot.

The DHCP should be configured to point to the NBP program. Here is a sample configuration for the isc-dhcp server. You need to modify the following configuration based on your network configuration and usage):

subnet 192.168.0.0 netmask 255.255.255.0 {
        range 192.168.0.11 192.168.0.20;
        option routers 192.168.0.1;

        # Required for PXE Boot
        class "pxeclients" {
                match if substring (option vendor-class-identifier, 0, 9) = "PXEClient";
                        filename "efi/grubnetaa64.efi.signed";
                        # TFTP Server IP address
                        next-server 192.168.0.1;
                        option root-path "/tftp/";
        }
}

host mytegra {
  hardware ethernet 48:B0:2D:B1:48:25;
  fixed-address 192.168.0.10;
}

The kernel and initrd can be taken from the board support package directory as Image and initrd, and are placed in the directory to which grub.cfg points.

For example, the following GRUB config pulls kernel/initrd from root of TFTP and boots from NFS location 192.168.42.1:/volume1/nfs_root:

set timeout_style=menu
set timeout=5

menuentry "Jetson" {
      linux /Image root=/dev/nfs rw netdevwait ip=:::::eth0:on nfsroot=192.168.42.1:/volume1/nfs_root fbcon=map:0 net.ifnames=0  console=ttyTCU0,115200 firmware_class.path=/etc/firmware fbcon=map:0 net.ifnames=0
      initrd /initrd
}

The TFTP server configuration using tftpd-hpa on an Ubuntu machine:

# /etc/default/tftpd-hpa

TFTP_USERNAME="<vrlhostname>"
TFTP_DIRECTORY="/tftp"
TFTP_ADDRESS=":69"
TFTP_OPTIONS="--secure"

The kernel, the initrd, and the GRUB bootloader need to be present at these locations:

/tftp/efi/grubnetaa64.efi.signed
/tftp/Image
/tftp/initrd

The NFS server /etc/exports configuration file on the NFS host with IP 192.168.42.1:

# /etc/exports
/volume1/nfs_root *(async,rw,no_root_squash,no_all_squash,no_subtree_check,insecure,anonuid=1000,anongid=1000)"

The root file system should be exported using an NFS server. After you finish configuring:

  1. Reboot the Jetson device.

  2. Press Esc during boot time to access the UEFI boot menu.

  3. Select the PXEv4 boot option of the network device from which you want to boot.

Bringing Up the Jetson Module for the initrd Flash Tool#

The initrd flash tool is validated to work with NVIDIA developer kits. For this tool to work on your custom carrier board with Jetson modules, ensure that a USB device mode has been enabled for your custom carrier board.

Often you need to customize the BSP. In some cases, customization might cause the BSP to fail to initrd flash the device. For these cases, initrd flash supports a separation of flashing environment and the content that is flashed:

  1. Create a new board configuration file that exposes the USB device mode for your custom carrier board, such as board_config_for_flashing.conf. This is a board configuration file that is the same as the original board configuration file but with modifications to enable USB device mode. For example:

    #jetson-agx-thor-devkit.conf
    ...
    DTB_FILE="tegra264-p4071-0000+p3834-0008-nv.dtb";
    ...
    
    #board_config_for_flashing.conf
    ...
    DTB_FILE="tegra264-p4071-0000+p3834-0008-nv-with-modifications-to-enable-usb-device-mode.dtb";
    ...
    
  2. Add the following line to your main board configuration file:

    FLASHING_CONFIG_FILE=board_config_for_flashing.cfg
    # Additionally you can provide your own boot image for the flashing kernel. For example:
    # _FLASHING_KERNEL="${LDK_DIR}/unified_flash/tools/flashtools/flashing_kernel/initramfs/t264/boot_flashing.img"
    
  3. Run the initrd flash command. The unified flash tool generates the flashing environment using board_config_for_flashing.cfg and the content for flashing using your main board configuration file.

Disable Bash Shell Launch for Production Devices#

The initrd file located in the root filesystem (/boot/initrd) is configured by default to launch a root bash shell. However, enabling this feature can lead to security vulnerabilities if any failures occur. Therefore, we strongly recommend disabling the bash shell launch for production devices.

  1. In the Linux_for_Tegra/rootfs/etc/nv-update-initrd/list.d/disable_initrd_bash file, uncomment the following line:

    #/etc/.disable_initrd_bash:/etc/.disable_initrd_bash
    
  2. Regenerate Linux_for_Tegra/rootfs/boot/initrd on the host machine by using the script Linux_for_Tegra/tools/l4t_update_initrd.sh. For example, run the following commands:

    $ cd Linux_for_Tegra
    $ sudo ./tools/l4t_update_initrd.sh
    
  3. Push the updated file to the device. Because Linux_for_Tegra/rootfs/boot/initrd is used for RCM boot and recovery image generation, the bash shell will not be launched during RCM boot or when booting with a recovery image.

Cloning rootfs with initrd#

  1. Put the Jetson device in Recovery Mode.

  2. Enter these commands on the host:

    $ cd Linux_for_Tegra
    $ sudo ./l4t_initrd_flash.sh --boot-rootfs --initrd <board-name> <rootdev>
    

    In the preceding command,

  3. Enter bash shell on the Jetson device.

  4. Plug a USB drive into the Jetson device and clone the rootfs partition as an exact copy of system.img.raw into this USB drive by running the following commands:

    $ mount /dev/sda1 /mnt
    $ dd if=<rootfs partition> of=/mnt/system.img.raw
    $ sync
    $ umount /mnt
    

    The value /dev/sda1 specifies the plugged-in USB drive. The <rootfs partition> might be /dev/mmcblk0p1 for an eMMC device or /dev/nvme0n1p1 for an NVMe device.

  5. Unplug the USB drive from the Jetson device and plug it into the host machine.

  6. Copy the system.img.raw file from the USB drive to the host machine.

  7. Convert it to the system.img sparse image by running the following command:

    $ cd Linux_for_Tegra
    $ ./bootloader/mksparse --fillpattern=0 system.img.raw system.img
    
  8. Flash system.img to the target device:

    $ sudo EXTOPTIONS="-r" ./l4t_initrd_flash.sh <board> internal
    

EEPROM Recovery#

After the board is flashed and boots up, to correct the EEPROM content, complete the following steps:

  1. Use the Linux i2c-tools to correct corrupted EEPROM content.

  2. Dump the complete EEPROM content with i2c-tools.

  3. Calculate the CRC8 value based on the result from step 2.

  4. Write the CRC8 value to byte 255 in EEPROM.

For more information about EEPROM content and calculating CRC8, refer to Jetson EEPROM Layout.

Note

This method should be used only for the CRC-8 checksum bit corruption in EEPROM. If your module has another faulty EEPROM or I2C, consider using RMA instead of this method.

RCM Booting#

RCM booting boots the board with l4t_initrd_flash.sh without performing the flashing operations. It is commonly used in debugging scenarios.

  1. Put the device into reset/recovery mode.

    • Power on the carrier board and hold down the Recovery button.

    • Press the Reset button.

  2. Enter the command:

    $ sudo ./l4t_initrd_flash.sh --initrd <board> internal
    

Note

To generate the RCM boot image offline, add --no-flash. When you are ready to boot the target, use --flash-only.

Enabling AGX Orin, Orin NX, and Orin Nano in USB3 Recovery Mode#

To enable Orin series devices in USB3 recovery mode, complete the following steps:

  1. Download and set up the Factory Secure Key Provisioning tool.

  2. Place the device in recovery mode and connect to the host PC.

  3. On the host PC, navigate to the Linux_for_Tegra folder.

  4. Create a Fuse configuration file called usb3.xml with the following content:

    <genericfuse MagicId="0x45535546" version="1.0.0">
    <fuse name="BootDevInfo" size="4" value="0x00000900"/>
    <fuse name="SwReserved" size="4" value="0x00000080"/>
    </genericfuse>
    
  5. Run the following command to use the fuse configuration file:

    # For Jetson Orin NX and Orin Nano series
    $ sudo ./fskp_fuseburn.py --board-spec orinnano-board-spec.txt -f usb3.xml -b -K -c 0x23 -B <project_base_directory>/Linux_for_Tegra/jetson-orin-nano-devkit.conf
    # For Jetson AGX Orin series
    $ sudo ./fskp_fuseburn.py --board-spec orin-agx-board-spec.txt -f usb3.xml -b -K -c 0x23 -B <project_base_directory>/Linux_for_Tegra/jetson-agx-orin-devkit.conf
    
  6. Reset the device into recovery mode and run the $ lsusb -t command to confirm that the device is in USB3 mode.

Note

This step is irreversible.

For more information about the fuse configuration file and fskp_fuseburn.py, refer to Fuse Configuration File in Secure Boot and Using the Fuse Burning Toolkit for T234 from the Jetson Download Center.

Retrieving Target Information and Preparing for Flashing#

Getting Board Specification and Fuse Information#

To collect the board specification variables needed for the offline-mode flashing command, use the --read-info option while the target is connected. This option reads and displays board, chip, fuse, and EEPROM information from the target device.

  • For a connected Jetson AGX Thor Developer Kit in recovery mode, run:

$ sudo ./flash.sh --read-info jetson-agx-thor-devkit internal
  • For a connected PKC- and SBK-fused AGX Orin Industrial board in recovery mode, run:

$ sudo ./flash.sh --read-info -u <pkc> -v <sbk> jetson-agx-orin-devkit-industrial internal

The following example shows the output for the Jetson AGX Orin Industrial board:

Board ID(3701) version(TS1) sku(0008) revision(D.0)
Preset RAMCODE is 4
Chip SKU(00:00:00:90) ramcode(4) fuselevel(fuselevel_production) board_FAB(TS1)
ECID is 0xE9012344705DE284200000000A0102C0

==== Fuse Info (bootloader/fuse_t234.bin) ====
PublicKeyHash: ad2474627c14e3f7f4944a832bd15d0640938a3dc162f558692458f3d12f9453e11bea2ec75df3f83e8b29c47fc3d2483d528d3e94a5469c4ba1ec61f1584b23
PkcPubkeyHash1: d87796fb510d79738f8509c98511be0bb79dcc17d204a2f0f0bea9680b91bd1273ee2ae7a8a6bdb8b95deb0f421e72404939ae20d12c82649712283027201f39
PkcPubkeyHash2: 99a5b6eac64dfb29698cb684165529e5d8650c1aab0e18b677c5d5f0998af53f8a8a1f09ad1d79368bc500e57eb199e9108fc7b1499995d869b028fec3f367db
BootSecurityInfo: 00002a09
ArmJtagDisable: 00000001
SecurityMode: 00000001
:
:

==== EEPROM content (bootloader/cvm.bin) ====
00000000: 02 00 fe 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
00000010: 00 00 00 0c 36 39 39 2d 31 33 38 33 34 2d 30 30  ....699-13834-00
00000020: 30 38 2d 34 30 31 20 41 2e 33 00 00 00 00 00 00  08-401 A.3......
:
:

The corresponding board specification variables for the jetson-agx-orin-devkit-industrial board are:

BOARDID=3701
FAB=TS1
BOARDSKU=0008
CHIP_SKU=00:00:00:90
RAMCODE_ID=4

Generating a Pre-signed EEPROM Reader#

To read EEPROM securely on the factory floor without exposing the burned key, use the --gen-read-eeprom option to generate a pre-signed, encrypted blob in a secure environment.

  • For a PKC- and SBK-fused Jetson AGX Thor Developer Kit, run:

$ sudo ./flash.sh --gen-read-eeprom -u <pkc_keylist> -v <sbk_keyfile> jetson-agx-thor-devkit internal
  • For a PKC- and SBK-fused Jetson AGX Orin Industrial board, run:

$ sudo ./flash.sh --gen-read-eeprom -u <pkc_keyfile> -v <sbk_keyfile> jetson-agx-orin-devkit-industrial internal

The flash command generates a read_eeprom.sh command script, along with all the required encrypted and signed binaries, to read EEPROM content. The script does not require you to provide PKC and SBK keys.

After you generate the preceding pre-signed EEPROM reader, put the target into recovery mode, and run the command for the target platform to read its EEPROM contents.

  • For Jetson Thor:

$ cd bootloader
$ sudo ./read_eeprom.sh 0x26
  • For Jetson Orin:

$ cd bootloader
$ sudo ./read_eeprom.sh 0x23

Dynamically Selecting the MEM-BCT for Flashing#

When you use the --read-ramcode option in the following example command, the ramcode is retrieved from the connected target device, and the corresponding MEM-BCT is selected for RCM boot before flashing. Without this option, a fixed ramcode is applied from the RAMCODE_ID value defined either in the board configuration file or on the command line. The --read-ramcode option applies only to Orin. For Thor, the ramcode is read automatically during flashing.

$ sudo ./l4t_initrd_flash.sh --read-ramcode -u <pkc> -v <sbk> jetson-agx-orin-devkit-industrial internal