Guide to Set Up U-boot Debug Environment on Arm DS for Total Compute Platform

The Arm Total Compute Platform utilizes U-Boot as the bootloader for the non-secure world. U-Boot is responsible for loading the Linux kernel, device tree, and root filesystem, providing the necessary foundation for the operating system to initialize, which allows the Total Compute Platform to seamlessly boot into Linux.

This guide describes:

How to set up the u-boot debug connection
How to load the u-boot debug symbol file
How to start the u-boot debug

This guide assumes that you already set up the debugging environment as described in the Guide to Set Up Debugging Environment for Total Compute Software Stack.

The guidance given in this guide is based on the Total Compute TC23.1 code.
Note: Future code updates might introduce changes, so the guidance might not apply to all cases.

Setting up u-boot debugging connection

The Guide to Set Up Debugging Environment for Total Compute Software Stack describes how to set up the Total Compute debugging environment in Arm DS.

There are some considerations to be aware of when setting up the u-boot debugging environment.

Select ARM_Cortex-A520x2 SMP Cluster 0 as your target as follows, when debugging the u-boot.

Loading the u-boot debugging symbol file

U-Boot is compiled as position-independent code and is loaded to a specified location by TF-A's BL2. This location is determined by the following code in both TF-A and U-Boot:
src/trusted-firmware-a/include/plat/arm/css/common/css_def.h:

#define PLAT_ARM_NS_IMAGE_BASE            U(0xE0000000)

src/u-boot/configs/total_compute_defconfig:

CONFIG_TEXT_BASE=0xe0000000

During U-Boot's initialization phase, it relocates itself to a different address. You can refer to the following code:

src/u-boot/arch/arm/lib/relocate_64.S:

ENTRY(relocate_code)
	stp	x29, x30, [sp, #-32]!	/* create a stack frame */
	mov	x29, sp
	str	x0, [sp, #16]
	/*
	 * Copy u-boot from flash to RAM
	 */
	adrp	x1, __image_copy_start		/* x1 <- address bits [31:12] */
	add	x1, x1, :lo12:__image_copy_start/* x1 <- address bits [11:00] */
	subs	x9, x0, x1			/* x9 <- Run to copy offset */
	b.eq	relocate_done			/* skip relocation */

To debug the code after relocating, you need to find the relocation offset. This is necessary to match the symbols in the symbol table with their corresponding runtime addresses. You can obtain this offset using the following command after U-Boot has booted to the command line:

TOTAL_COMPUTE# bdinfo
boot_params = 0x0000000000000000
DRAM bank   = 0x0000000000000000
-> start    = 0x0000000080000000
-> size     = 0x0000000079000000
DRAM bank   = 0x0000000000000001
-> start    = 0x0000000880000000
-> size     = 0x0000000170000000
flashstart  = 0x0000000000000000
flashsize   = 0x0000000000000000
flashoffset = 0x0000000000000000
baudrate    = 115200 bps
relocaddr   = 0x00000000f875c000
reloc off   = 0x000000001875c000
Build       = 64-bit
fdt_blob    = 0x00000000f2b58b90
new_fdt     = 0x00000000f2b58b90
fdt_size    = 0x0000000000003220
lmb_dump_all:
 memory.cnt = 0x2 / max = 0x10
 memory[0]      [0x80000000-0xf8ffffff], 0x79000000 bytes flags: 0
 memory[1]      [0x880000000-0x9efffffff], 0x170000000 bytes flags: 0
 reserved.cnt = 0x3 / max = 0x10
 reserved[0]    [0xf1b54000-0xf8ffffff], 0x074ac000 bytes flags: 0
 reserved[1]    [0xf2b54590-0xf8ffffff], 0x064aba70 bytes flags: 0
 reserved[2]    [0x880000000-0x9efffffff], 0x170000000 bytes flags: 0
devicetree  = board
arch_number = 0x0000000000000000
TLB addr    = 0x00000000f87f0000
irq_sp      = 0x00000000f2b58b80
sp start    = 0x00000000f2b58b80
Early malloc usage: 910 / 2000

The "reloc off" is the value that will be used in the add-symbol-file commands. If you need to debug both the code before and after relocation, you'll need to add the symbol table twice, as shown below:

add-symbol-file /workspace/arm/tc23.1/output/tc3/buildroot/fvp/tmp_build/u-boot/u-boot  EL2N:0
add-symbol-file /workspace/arm/tc23.1/output/tc3/buildroot/fvp/tmp_build/u-boot/u-boot  EL2N:0x000000001875c000

In the Debugger tab of the u-boot debug configuration, include corresponding commands in Execute Debugger Commands to add symbol tables, as shown in the following figure. Each time the debugging connection starts, these commands are automatically executed to load the symbol table files.

You can also add other commands here, such as setting breakpoints:

break _main
break do_bdinfo

The commands will automatically execute after the connect to the target like below:

Starting the u-boot debugging

When connecting the u-boot debug connection, you will find the all cores are power down and the continue button is grey

To make the Application Processor core power on, you need create a SCP debug connection according to Guide to Debug RSS Firmware Booting on Total Compute Platform, and then connect the SCP target as below:

You can set any breakpoints at the u-boot connection and then click the continue button at the SCP connection. The application processor core 0 will be powered up by the SCP as below:

The application processor will stop at the breakpoint and you can use the continue button to continue debug the u-boot: