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>
optionsis 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.shgets the configuration from a configuration file named<board>.conf.<board>.confspecifies 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 valueinternalto 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#
Put the target device into Force Recovery Mode.
Power on the carrier board and hold down the RECOVERY button.
Press the RESET button.
Run the
tools/kernel_flash/l4t_initrd_flash.shscript 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>
<board>specifies the configuration of the target device, as described by the Jetson Modules and Configurations table.<rootdev>specifies the device on which the root file system is located, as described in Basic Flashing Script Usage.
For example, run the script like this:
$ sudo ./l4t_initrd_flash.sh <board> internal
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.keyoption 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 theEXTERNAL_DEVICEvariable or the--external-deviceoption. This variable is optional; you can provide the information by using the-coption instead.EXTERNAL_DEVICE: Specifies the default external storage device to be flashed for theEXTERNAL_PT_LAYOUTvariable. 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:
Place the Jetson target into recovery mode.
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.
Connect the five Jetson devices to the flashing hosts.
Ensure that the devices have the same hardware revision.
Place all connected Jetson devices into RCM mode.
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
ioniceto 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,
<partition_name>is the name of the partition to be flashed. Possible values depend on the target device. For specific filenames, see the table of Partition Configuration Files.<board>is the configuration of the target device as specified in the Jetson Modules and Configurations table.<rootdev>specifies the device on which the root file system is located, as described in Basic Flashing Script Usage.
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#
Put the device into recovery mode: Power the carrier board on, press and hold the RECOVERY button, and then press the RESET button.
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 nvme0n1p1specifies 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.xmlis 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
/bootdirectory 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:
Reboot the Jetson device.
Press Esc during boot time to access the UEFI boot menu.
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:
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"; ...
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"Run the initrd flash command. The unified flash tool generates the flashing environment using
board_config_for_flashing.cfgand 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.
In the
Linux_for_Tegra/rootfs/etc/nv-update-initrd/list.d/disable_initrd_bashfile, uncomment the following line:#/etc/.disable_initrd_bash:/etc/.disable_initrd_bash
Regenerate
Linux_for_Tegra/rootfs/boot/initrdon the host machine by using the scriptLinux_for_Tegra/tools/l4t_update_initrd.sh. For example, run the following commands:$ cd Linux_for_Tegra $ sudo ./tools/l4t_update_initrd.sh
Push the updated file to the device. Because
Linux_for_Tegra/rootfs/boot/initrdis 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#
Put the Jetson device in Recovery Mode.
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,
<board-name>is the value of the environment variableBOARDfor the target device. See Jetson Modules and Configurations.<rootdev>specifies the device on which the root file system is located, as described in Basic Flashing Script Usage.
Enter bash shell on the Jetson device.
Plug a USB drive into the Jetson device and clone the rootfs partition as an exact copy of
system.img.rawinto 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/sda1specifies the plugged-in USB drive. The<rootfs partition>might be/dev/mmcblk0p1for an eMMC device or/dev/nvme0n1p1for an NVMe device.Unplug the USB drive from the Jetson device and plug it into the host machine.
Copy the
system.img.rawfile from the USB drive to the host machine.Convert it to the
system.imgsparse image by running the following command:$ cd Linux_for_Tegra $ ./bootloader/mksparse --fillpattern=0 system.img.raw system.img
Flash
system.imgto 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:
Use the Linux i2c-tools to correct corrupted EEPROM content.
Dump the complete EEPROM content with i2c-tools.
Calculate the CRC8 value based on the result from step 2.
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.
Put the device into reset/recovery mode.
Power on the carrier board and hold down the Recovery button.
Press the Reset button.
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:
Download and set up the Factory Secure Key Provisioning tool.
Place the device in recovery mode and connect to the host PC.
On the host PC, navigate to the
Linux_for_Tegrafolder.Create a Fuse configuration file called
usb3.xmlwith 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>
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
Reset the device into recovery mode and run the
$ lsusb -tcommand 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