[TOC]
Debugging Methods
This chapter mainly introduces some commonly used debugging methods in the U-Boot phase, including the use of commands, scripts, configuration options, boot messages, etc.
DEBUG
Function: Enable global debug() printing.
You can add a macro definition in rkxxx_common.h for each platform to enable it:
#define DEBUG
Initcall
Function: Print the boot flow.
U-Boot's boot is essentially a series of initcall calls. Change debug() to printf() in the initcall_run_list() function. Example:
U-Boot 2017.09-01725-g03b8d3b-dirty (Jul 06 2018 - 10:08:27 +0800)
initcall: 0000000000214388
initcall: 0000000000214724
Model: Rockchip RK3399 Evaluation Board
initcall: 0000000000214300
DRAM: initcall: 0000000000203f68
initcall: 0000000000214410 // Combine with disassembly to find the function corresponding to the address
initcall: 00000000002140dc
....
3.8 GiB
initcall: 00000000002143b8
....
Relocation Offset is: f5c03000
initcall: 00000000f5e176bc
initcall: 00000000002146a4 (relocated to 00000000f5e176a4)
initcall: 0000000000214668 (relocated to 00000000f5e17668)
...
io Command
Function: Read/write memory.
// Read operation
md - memory display
Usage: md [.b, .w, .l, .q] address [# of objects]
// Write operation
mw - memory write (fill)
Usage: mw [.b, .w, .l, .q] address value [count]
Read operation. Example: Display 0x10 consecutive data starting from address 0x76000000.
=> md.l 0x76000000 0x10
76000000: fffffffe ffffffff ffffffff ffffffff ................
76000010: ffffffdf ffffffff feffffff ffffffff ................
76000020: ffffffff ffffffff ffffffff ffffffff ................
76000030: ffffffff ffffffff ffffffff ffffffff ................
Write operation. Example: Assign value 0x1234 to address 0x76000000.
=> mw.l 0x76000000 0xffff1234 // High 16 bits have mask
=> md.l 0x76000000 0x10 // Read back
76000000: ffff1234 ffffffff ffffffff ffffffff ................
76000010: ffffffdf ffffffff feffffff ffffffff ................
76000020: ffffffff ffffffff ffffffff ffffffff ................
76000030: ffffffff ffffffff ffffffff ffffffff ................
iomem Command
Function: Read memory. More flexible than the md command, it automatically resolves DTS node to get the base address.
=> iomem
iomem - Show iomem data by device compatible
Usage:
// @<compatible>: Keyword matching of the node's compatible part
iomem <compatible> <start offset> <end offset>
eg: iomem -grf 0x0 0x200
Example: RK3228 read GRF data from 0x00 to 0x20:
// Here, "-grf" is used as the keyword to distinguish it from "rockchip, rk3288-pmugrf"
=> iomem -grf 0x0 0x20
rockchip,rk3228-grf:
11000000: 00000000 00000000 00004000 00002000
11000010: 00000000 00005028 0000a5a5 0000aaaa
11000020: 00009955
i2c Command
Function: Read/write i2c devices.
=> i2c
i2c - I2C sub-system
Usage:
i2c dev [dev] - show or set current I2C bus
i2c md chip address[.0, .1, .2] [# of objects] - read from I2C device
i2c mw chip address[.0, .1, .2] value [count] - write to I2C device (fill)
......
Read operation. Example:
=> i2c dev 0 // Switch to i2c0 (specify once)
Setting bus to 0
=> i2c md 0x1b 0x2e 0x20 // i2c device address is 0x1b (7-bit address), read 0x20 consecutive register values starting from 0x2e
002e: 11 0f 00 00 11 0f 00 00 01 00 00 00 09 00 00 0c ................
003e: 00 0a 0a 0c 0c 0c 00 07 07 0a 00 0c 0c 00 00 00 ................
Write operation. Example:
=> i2c dev 0 // Switch to i2c0 (specify once)
Setting bus to 0
=> i2c mw 0x1b 0x2e 0x10 // i2c device address is 0x1b (7-bit address), assign 0x10 to register 0x2e
=> i2c md 0x1b 0x2e 0x20 // Read back
002e: 10 0f 00 00 11 0f 00 00 01 00 00 00 09 00 00 0c ................
003e: 00 0a 0a 0c 0c 0c 00 07 07 0a 00 0c 0c 00 00 00 ................
gpio Command
Function: Pin input/output read/write
=> gpio
gpio - query and control gpio pins
Usage:
gpio <input|set|clear|toggle> <pin>
- input/set/clear/toggle the specified pin
gpio status [-a] [<bank> | <pin>] - show [all/claimed] GPIOs
View pin status: e.g., RV1126
=> gpio status -a
Bank A:
A0: input: 0 [ ]
A1: output: 1 [ ]
A2: input: 1 [ ]
...
A29: unused: 1 [ ]
A30: unknown
A31: unused: 0 [ ]
...
D6: input: 0 [ ]
D7: output: 1 [x] vcc18-lcd-n.gpio
...
D31: input: 0 [ ]
Bank E:
E0: input: 0 [ ]
E1: input: 0 [ ]
Pin input:
=> gpio input A7
Pin output INACTIVE:
=> gpio clear A7
Pin output ACTIVE:
=> gpio set A7
Pin state toggle: e.g., A7: input: 0 -> A7: output: 1
=> gpio toggle A7
fdt Command
Function: Print DTB content.
=> fdt
fdt - flattened device tree utility commands
Usage:
fdt addr [-c] <addr> [<length>] - Set the [control] fdt location to <addr>
fdt print <path> [<prop>] - Recursive print starting at <path>
fdt list <path> [<prop>] - Print one level starting at <path>
......
NOTE: Dereference aliases by omitting the leading '/', e.g. fdt print ethernet0.
The following two combined commands can dump the complete device-tree:
=> fdt addr $fdt_addr_r // Specify fdt address
=> fdt print // Print all fdt content
mmc Command
Function: MMC device read/write, switching.
MMC device info:
=> mmc info
Device: dwmmc@ff0f0000 // Device node
Manufacturer ID: 15
OEM: 100
Name: 8GME4
Timing Interface: High Speed // Speed mode
Tran Speed: 52000000 // Current speed
Rd Block Len: 512
MMC version 5.1
High Capacity: Yes
Capacity: 7.3 GiB // Storage capacity
Bus Width: 8-bit // Bus width
Erase Group Size: 512 KiB
HC WP Group Size: 8 MiB
User Capacity: 7.3 GiB WRREL
Boot Capacity: 4 MiB ENH
RPMB Capacity: 512 KiB ENH
MMC device switching:
=> mmc dev 0 // Switch to eMMC
=> mmc dev 1 // Switch to SD card
MMC device read/write:
mmc read addr blk# cnt
mmc write addr blk# cnt
mmc erase blk# cnt
Example:
=> mmc read 0x70000000 0 1 // Read the first block of the MMC device, 1 sector of data to memory at 0x70000000
=> mmc write 0x70000000 0 1 // Write 1 sector of data from memory at 0x70000000 to the first block of the storage
=> mmc erase 0 1 // Erase 1 sector starting from the first block of the storage
If the MMC device read/write is abnormal, you can quickly locate the issue through the following simple steps:
Change debug() to printf() in drivers/mmc/dw_mmc.c, then recompile and flash. Check the MMC device's print information:
- If the last print is Sending CMD0, please check the hardware power supply and pin connections; check if the software IOMUX has been taken by another IP.
- If the last print is Sending CMD8, configure the MMC device to allow access to secure storage in the security software part.
- If all initialization commands have passed and the last print is Sending CMD18, please check the MMC hardware power supply, whether the capacitors near the MMC power supply terminal are sufficient (try replacing with larger capacitors), and in software, reduce the clock frequency or switch the MMC device's speed mode.
Timestamp
Function: Add timestamps (relative time) to U-Boot print information.
CONFIG_BOOTSTAGE_PRINTF_TIMESTAMP
Example:
[ 0.259266] U-Boot 2017.09-01739-g856f373-dirty (Jul 10 2018 - 20:26:05 +0800)
[ 0.260596] Model: Rockchip RK3399 Evaluation Board
[ 0.261332] DRAM: 3.8 GiB
Relocation Offset is: f5bfd000
Using default environment
[ 0.354038] dwmmc@fe320000: 1, sdhci@fe330000: 0
[ 0.521125] Card did not respond to voltage select!
[ 0.521188] mmc_init: -95, time 9
[ 0.671451] switch to partitions #0, OK
[ 0.671500] mmc0(part 0) is current device
[ 0.675507] boot mode: None
[ 0.683738] DTB: rk-kernel.dtb
[ 0.706940] Using kernel dtb
......
The timestamp only prints the current system timer time, not starting from 0. Therefore, the timestamp prints only relative time, not absolute time.
dm tree
Function: View the binding and probe status of all device-driver pairs.
=> dm tree
Class Probed Driver Name
----------------------------------------------------------
root [ + ] root_driver root_driver
syscon [ ] rk322x_syscon |-- syscon@11000000
serial [ + ] ns16550_serial |-- serial@11030000 *
clk [ + ] clk_rk322x |-- clock-controller@110e0000
sysreset [ ] rockchip_sysreset | |-- sysreset
reset [ ] rockchip_reset | `-- reset
mmc [ + ] rockchip_rk3288_dw_mshc |-- dwmmc@30020000 *
blk [ + ] mmc_blk | `-- dwmmc@30020000.blk *
ram [ ] rockchip_rk322x_dmc |-- dmc@11200000
serial [ + ] ns16550_serial |-- serial@11020000
i2c [ + ] i2c_rockchip |-- i2c@11050000
......
Print meaning:
- Lists all device-drivers that have completed binding.
- Lists all uclass-device-driver affiliation relationships.
- [ + ] indicates that the current driver has completed probe.
- * indicates that the current device-driver comes from U-Boot's DTB, otherwise it comes from kernel DTB.
dm uclass
Function: View all devices under a certain uclass.
=> dm uclass
uclass 0: root
- * root_driver @ 7be54c88, seq 0, (req -1)
uclass 11: adc
- * saradc@ff100000 @ 7be56220, seq 0, (req -1)
......
uclass 40: backlight
- * backlight @ 7be81178, seq 0, (req -1)
uclass 77: key
- rockchip-key @ 7be811f0
......
stacktrace.sh
Use the call stack backtracking mechanism to analyze abort and dump_stack() scenes. Please refer to the RK Architecture chapter.
System Hang
Function: Print the current CPU's scene and call stack, suitable for use when the system hangs. The serial port will dump information similar to an abort every 5 seconds.
CONFIG_ROCKCHIP_DEBUGGER
After obtaining the call stack information, use the stacktrace script to convert it. Please refer to the RK Architecture chapter.
CRC Verification
Function: Verify the integrity of RK format firmware.
The RK format image header contains the CRC32 of the entire image. Enable the following macro to use CRC32 to verify firmware integrity.
CONFIG_ROCKCHIP_CRC
Example:
=Booting Rockchip format image=
kernel image CRC32 verify... okay. // kernel verification successful (prints "fail!" if failed)
boot image CRC32 verify... okay. // boot verification successful (prints "fail!" if failed)
kernel @ 0x02080000 (0x01249808)
ramdisk @ 0x0a200000 (0x001e6650)
# Flattened Device Tree blob at 01f00000
Booting using the fdt blob at 0x1f00000
'reserved-memory' secure-memory@20000000: addr=20000000 size=10000000
Loading Ramdisk to 08019000, end 081ff650 ... OK
Loading Device Tree to 0000000008003000, end 0000000008018c97 ... OK
Adding bank: start=0x00200000, size=0x08200000
Adding bank: start=0x0a200000, size=0xede00000
Starting kernel ...
HASH Verification
Function: Verify the integrity of Android format firmware.
ANDROID_BOOT_IMAGE_HASH
After enabling this configuration, the integrity of the firmware will be verified when loading Android format firmware.
Due to historical reasons, if the above configuration cannot correctly verify the firmware, please also enable the following configuration:
HASH_ROCKCHIP_LEGACY
Modifying DDR Capacity
At boot, the DDR initialization code passes the DDR capacity to U-Boot. U-Boot removes some secure memory and then passes it to the kernel. Users can modify the DDR capacity passed to the kernel during the U-Boot phase.
Passing example:
......
// Available memory blocks passed to the kernel (secure memory blocks have been removed).
Adding bank: 0x00200000 - 0x08400000 (size: 0x08200000)
Adding bank: 0x0a200000 - 0x40000000 (size: 0x35e00000)
Total: 895.411 ms
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
Code location:
./arch/arm/mach-rockchip/param.c
Modification location:
struct memblock *param_parse_ddr_mem(int *out_count)
{
......
// This is the capacity information passed from ddr to U-Boot.
// Since non-contiguous addresses may occur, it is passed in blocks,
// indicating the start address and size of each memory block.
// PS: Generally, it is contiguous memory, so no block splitting is needed.
for (i = 0, n = 0; i < count; i++, n++) {
// For example, 2GB capacity (contiguous address): count=1, base = 0, size = 0x80000000.
// Users can modify as needed during debugging.
base = t->u.ddr_mem.bank[i];
size = t->u.ddr_mem.bank[i + count];
/* 0~4GB */
if (base < SZ_4GB) {
mem[n].base = base;
mem[n].size = ddr_mem_get_usable_size(base, size);
if (base + size > SZ_4GB) {
n++;
mem[n].base_u64 = SZ_4GB;
mem[n].size_u64 = base + size - SZ_4GB;
}
} else {
/* 4GB+ */
mem[n].base_u64 = base;
mem[n].size_u64 = size;
}
assert(n < count + MEM_RESV_COUNT);
}
......
}
Jump Information
Function: Confirm firmware version and flow. In some cases, boot information can also help users locate some crash issues.
- System hangs after trust finishes
Possible reason: The firmware packaging or flashing is faulty, causing trust to jump to the wrong U-Boot start address. Users can confirm through the U-Boot start address printed by trust.
For 64-bit platforms, the U-Boot start address is typically offset 0x200000 (DRAM start address is 0x0):
NOTICE: BL31: v1.3(debug):d98d16e
NOTICE: BL31: Built : 15:03:07, May 10 2018
NOTICE: BL31: Rockchip release version: v1.1
INFO: GICv3 with legacy support detected. ARM GICV3 driver initialized in EL3
INFO: Using opteed sec cpu_context!
INFO: boot cpu mask: 0
INFO: plat_rockchip_pmu_init(1151): pd status 3e
INFO: BL31: Initializing runtime services
INFO: BL31: Initializing BL32
INFO: BL31: Preparing for EL3 exit to normal world
INFO: Entry point address = 0x200000 // U-Boot address
INFO: SPSR = 0x3c9
For 32-bit platforms, the U-Boot start address is typically offset 0x0 (DRAM start address is 0x60000000):
INF [0x0] TEE-CORE:init_primary_helper:378: Release version: 1.9
INF [0x0] TEE-CORE:init_primary_helper:379: Next entry point address: 0x60000000 // U-Boot address
INF [0x0] TEE-CORE:init_teecore:83: teecore inits done
- U-Boot version backtracking:
The compilation version can be backtracked through the U-Boot boot information. The following corresponds to commit: b34f08b.
U-Boot 2017.09-01730-gb34f08b (Jul 06 2018 - 17:47:52 +0800)
If "dirty" appears in the boot information, it means there were local modifications at compile time that were not committed to the repository, so the compile point is not clean.
U-Boot 2017.09-01730-gb34f08b-dirty (Jul 06 2018 - 17:35:04 +0800)
Boot Information
Users can obtain the current U-Boot flow and the status of various peripherals through the U-Boot boot information, making it easy to quickly locate anomalies.
Currently, U-Boot supports three firmware type boot methods: Android format > RK format > DISTRO format. The RK SDK mainly uses the first two firmware formats, while DISTRO is generally used by open-source users.
Note: If the user's code is not new enough, some prints may not be visible, but this does not affect the user's overall understanding of the U-Boot boot information.
Android Firmware
// The first line of U-Boot print, containing commit version, compile time, etc.
// Note: This is only the "relatively early" first official print of U-Boot, not the earliest print U-Boot can make.
// Enable debug information to see earlier debug prints.
U-Boot 2017.09-03033-g81b79f7-dirty (Jul 04 2019 - 15:04:00 +0800)
// Content of the "model" field of U-Boot dts; through this information, we can know which dts U-Boot is using.
Model: Rockchip RK3399 Evaluation Board
// Preloader-serial function enabled, meaning the serial port configuration from the previous loader is used; currently using UART2 as the print port.
PreSerial: 2
// Total memory capacity of the board is 2GB.
DRAM: 2 GiB
// Current version supports sysmem memory card management mechanism.
Sysmem: init
// U-Boot will relocate its own code from the front position of the current ddr to a later position (see the U-Boot development document for boot flow).
// The start address of the relocated code is 0x7dbe2000; this information may be useful during disassembly debugging.
Relocation Offset is: 7dbe2000
// ENV is saved in ddr by default. If saved in storage media like eMMC, Nand, etc., this print will not appear.
Using default environment
// Current storage media is mmc0, i.e., eMMC (if SD card, it's mmc1).
dwmmc@fe320000: 1, sdhci@fe330000: 0
// The storage media type is passed from the previous miniloader to U-Boot via atags.
Bootdev(atags): mmc 0
// Current eMMC is working in HS400 mode, clock frequency is 150M.
MMC0: HS400, 150Mhz
// Currently using GPT partition table (if RK parameter partition table, it prints: RKPARM).
PartType: EFI
// Currently in recovery mode.
// The "reboot xxx" command executed in the kernel is also reflected by this print.
boot mode: recovery
// Kernel DTB comes from recovery.img and is loaded normally.
Load FDT from recovery part
DTB: rk-kernel.dtb
HASH: OK(c)
// ==> Note: After this point, U-Boot has switched to kernel dtb, and all subsequent peripheral drivers use the information from kernel dtb!!
// DTBO execution successful.
ANDROID: fdt overlay OK
// I2C speed is one of the factors affecting U-Boot boot speed, especially for PMICs with many DCDC and LDO regulators.
// If users care about boot speed, they can pay attention to this information.
I2c speed: 400000Hz
// Current PMIC is RK818.
// The "on" value corresponds to the ON_SOURCE register, indicating the reason for this PMIC power-on.
// The "off" value corresponds to the OFF_SOURCE register, indicating the reason for the last shutdown or power failure.
// The "on" and "off" information is valuable when the system experiences abnormal restarts or shutdowns.
PMIC: RK818 (on=0x20 off=0x40)
// Current voltage values of each adjustable regulator, generally DCDC corresponding to RK platform arm, logic, center, etc.
// This is valuable information when the system has boot anomalies or boot instability.
vdd_center 900000 uV
vdd_cpu_l 900000 uV
vdd_log 900000 uV
// Content of the "model" field of Kernel dts; through this information, we can know which Kernel dts is used.
Model: Rockchip RK3399 Excavator Board edp avb (Android)
enter Recovery mode!
// Display driver related information.
Rockchip UBOOT DRM driver version: v1.0.1
Using display timing dts
Detailed mode clock 200000 kHz, flags[a]
H: 1536 1548 1564 1612
V: 2048 2056 2060 2068
bus_format: 100e
// clk-tree information, please refer to the CLK chapter in the U-Boot development document for details.
CLK: (uboot. arml: enter 816000 KHz, init 816000 KHz, kernel 0N/A)
CLK: (uboot. armb: enter 24000 KHz, init 24000 KHz, kernel 0N/A)
aplll 816000 KHz
apllb 24000 KHz
dpll 800000 KHz
cpll 200000 KHz
gpll 800000 KHz
npll 600000 KHz
vpll 24000 KHz
aclk_perihp 133333 KHz
hclk_perihp 66666 KHz
pclk_perihp 33333 KHz
aclk_perilp0 266666 KHz
hclk_perilp0 88888 KHz
pclk_perilp0 44444 KHz
hclk_perilp1 100000 KHz
pclk_perilp1 50000 KHz
// GMAC driver enabled.
Net: eth0: ethernet@fe300000
// Press and hold ctrl+c during boot to enter U-Boot command line mode after the following print.
Hit key to stop autoboot('CTRL+C'): 0
// Again, know that currently in recovery mode.
ANDROID: reboot reason: "recovery"
// vboot=0 indicates that secureboot is not enabled; currently it is an AVB firmware, so the standard AVB verification flow will be followed.
Vboot=0, AVB images, AVB verify
// Whether the device is unlocked.
read_is_device_unlocked() ops returned that device is UNLOCKED
// Native U-Boot loads the entire boot.img/recovery.img, then relocates ramdisk, fdt, and kernel to user-predetermined addresses.
// This is time-consuming, especially when the ramdisk is very large.
// The RK platform has modified this to directly load ramdisk, fdt, and kernel from storage to predetermined memory addresses in one go.
// The following print indicates that this one-time relocation operation has been enabled, saving time.
Fdt Ramdisk skip relocation
// Load Android format firmware, loading kernel to 0x00280000, fdt to 0x8300000.
// If it is an LZ4 compressed kernel, the print might be:
// Booting LZ4 kernel at 0x00680000(Uncompress to 0x00280000) with fdt at 0x8300000...
Booting IMAGE kernel at 0x00280000 with fdt at 0x8300000...
// Ignore, not important.
## Booting Android Image at 0x0027f800 ...
// Kernel and ramdisk load addresses and sizes.
Kernel load addr 0x00280000 size 19081 KiB
RAM disk load addr 0x0a200000 size 9627 KiB
// fdt load address.
## Flattened Device Tree blob at 08300000
Booting using the fdt blob at 0x8300000
// Ignore, not important.
XIP Kernel Image ... OK
// This is just printing the reserved-memory specified in kernel dts, which can be used as analysis information for kernel boot issues.
'reserved-memory' secure-memory@20000000: addr=20000000 size=10000000
// fdt start and end addresses.
Using Device Tree in place at 0000000008300000, end 000000000831c6f7
// Passed to kernel, informing the kernel of the available memory space range (ATF, optee, etc. space has been removed).
Adding bank: 0x00200000 - 0x08400000 (size: 0x08200000)
Adding bank: 0x0a200000 - 0x80000000 (size: 0x75e00000)
// U-Boot phase boot time.
Total: 367.128 ms
// Printed by U-Boot. After this print, U-Boot completes some ARM architecture-related work (e.g., cache clearing, interrupt disabling,
// CPU state switching, etc.) and U-Boot dm device removal. The probability of issues is extremely low.
// After completing the above work, it jumps to kernel. Therefore, it can be understood that once this print appears, it has reached the kernel stage.
Starting kernel ...
// Kernel stage print information.
[ 0.000000] Booting Linux on physical CPU 0x0
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
[ 0.000000] Initializing cgroup subsys cpuacct
[ 0.000000] Initializing cgroup subsys schedtune
[ 0.000000] Linux version 4.4.167 (hgc@ubuntu) (gcc version 6.3.1 20170404 (Linaro GCC 6.3-2017.05)) #83 SMP PREEMPT Thu Mar 21 09:31:08 CST 2019
[ 0.000000] Boot CPU: AArch64 Processor [410fd034]
[ 0.000000] earlycon: Early serial console at MMIO32 0xff1a0000 (options '')
[ 0.000000] bootconsole [uart0] enabled
[ 0.000000] Reserved memory: failed to reserve memory for node 'stb-devinfo@00000000': base 0x0000000000000000, size 0 MiB
[ 0.000000] cma: Reserved 16 MiB at 0x000000007f000000
......
RK Firmware
U-Boot 2017.09-03352-gb1265b5 (Jul 12 2019 - 09:57:24 +0800)
Model: Rockchip RK3399 Evaluation Board
PreSerial: 2
DRAM: 2 GiB
Sysmem: init
Relocation Offset is: 7dbe2000
Using default environment
......
Hit key to stop autoboot('CTRL+C'): 0
ANDROID: reboot reason: "recovery"
// Since it is RK format firmware, it cannot be AVB format.
Not AVB images, AVB skip
// Since it is RK format firmware, it will prompt that loading android format firmware failed.
// The current boot priority is: android format > RK format > distro format.
** Invalid Android Image header **
Android image load failed
Android boot failed, error -1.
// Currently in recovery mode.
boot mode: recovery
// Boot RK format firmware, loading ramdisk, kernel, fdt.
=Booting Rockchip format image=
fdt @ 0x08300000 (0x00012dd0)
kernel @ 0x00280000 (0x0119e008)
ramdisk @ 0x0a200000 (0x00754540)
// Below is basically similar to android format firmware boot information.
Fdt Ramdisk skip relocation
## Flattened Device Tree blob at 08300000
Booting using the fdt blob at 0x8300000
Using Device Tree in place at 0000000008300000, end 0000000008315dcf
Adding bank: 0x00200000 - 0x08400000 (size: 0x08200000)
Adding bank: 0x0a200000 - 0x80000000 (size: 0x75e00000)
Total: 508.11 ms
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
......
Distro Firmware
U-Boot 2017.09-03352-gb1265b5 (Jul 12 2019 - 09:57:24 +0800)
Model: Rockchip RK3399 Evaluation Board
PreSerial: 2
DRAM: 2 GiB
Sysmem: init
Relocation Offset is: 7dbe2000
Using default environment
......
// Found mmc0, i.e., eMMC.
switch to partitions #0, OK
mmc0(part 0) is current device
// Look for firmware on the 6th partition of eMMC storage (in GPT partition table, 6 corresponds to boot.img partition; in GPT, it is indicated by the "-bootable" attribute).
Scanning mmc 0:6...
// Found the configuration file extlinux.conf.
Found /extlinux/extlinux.conf
Retrieving file: /extlinux/extlinux.conf
// Load kernel.
205 bytes read in 82 ms (2 KiB/s)
1: rockchip-kernel-4.4
Retrieving file: /Image
13484040 bytes read in 1833 ms (7 MiB/s)
// cmdline information specified at packaging.
append: earlycon=uart8250,mmio32,0xff1a0000 console=ttyS2,1500000n8 rw
root=/dev/mmcblk0p7 rootwait rootfstype=ext4 init=/sbin/init
// Load fdt.
Retrieving file: /rk3399.dtb
61714 bytes read in 54 ms (1.1 MiB/s)
// ==> If there is no ramdisk during packaging, no ramdisk information will be printed; otherwise, it will be printed here.
## Flattened Device Tree blob at 01f00000
Booting using the fdt blob at 0x1f00000
Loading Device Tree to 000000007df14000, end 000000007df26111 ... OK
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
......
No Valid Firmware
U-Boot 2017.09-03352-gb1265b5 (Jul 12 2019 - 09:57:24 +0800)
Model: Rockchip RK3399 Evaluation Board
PreSerial: 2
DRAM: 2 GiB
Sysmem: init
Relocation Offset is: 7dbe2000
Using default environment
......
// Found mmc0, i.e., eMMC.
Boot information when firmware is not found.
switch to partitions #0, OK
mmc0(part 0) is current device
// Look for firmware on the 6th partition of eMMC storage (in GPT partition table, 6 corresponds to boot.img partition; in GPT, it is indicated by the "-bootable" attribute).
Scanning mmc 0:6...
// Found the configuration file extlinux.conf.
Found /extlinux/extlinux.conf
Retrieving file: /extlinux/extlinux.conf
// Load kernel.
205 bytes read in 82 ms (2 KiB/s)
1: rockchip-kernel-4.4
Retrieving file: /Image
13484040 bytes read in 1833 ms (7 MiB/s)
// cmdline information specified at packaging.
append: earlycon=uart8250,mmio32,0xff1a0000 console=ttyS2,1500000n8 rw
root=/dev/mmcblk0p7 rootwait rootfstype=ext4 init=/sbin/init
// Load fdt.
Retrieving file: /rk3399.dtb
61714 bytes read in 54 ms (1.1 MiB/s)
// ==> If there is no ramdisk during packaging, no ramdisk information will be printed; otherwise, it will be printed here.
## Flattened Device Tree blob at 01f00000
Booting using the fdt blob at 0x1f00000
Loading Device Tree to 000000007df14000, end 000000007df26111 ... OK
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
......
U-Boot 2017.09-03352-gb1265b5 (Jul 12 2019 - 09:57:24 +0800)
Model: Rockchip RK3399 Evaluation Board
PreSerial: 2
DRAM: 2 GiB
Sysmem: init
Relocation Offset is: 7dbe2000
Using default environment
......
Net: eth0: ethernet@fe300000
Hit key to stop autoboot('CTRL+C'): 0 ANDROID: reboot reason: "recovery"
// Not Android format firmware.
Not AVB images, AVB skip
** Invalid Android Image header **
Android image load failed
Android boot failed, error -1.
boot mode: recovery
// Not RK format firmware.
=Booting Rockchip format image=
kernel: invalid image tag(0x45435352)
boot_rockchip_image kernel part read error
// Not DISTRO format firmware. All subsequent prints come from distro load commands, as distro commands try to find distro firmware from mmc, nand, net,
// usb, and other predefined devices (see the macro definition in rockchip-common.h: BOOT_TARGET_DEVICES) by scanning them one by one.
switch to partitions #0, OK
mmc0(part 0) is current device
Failed to mount ext2 filesystem...
** Unrecognized filesystem type **
starting USB...
USB0: Register 2000140 NbrPorts 2
Starting the controller
USB XHCI 1.10
USB1: Register 2000140 NbrPorts 2
Starting the controller
USB XHCI 1.10
USB2: USB EHCI 1.00
USB3: USB OHCI 1.0
USB4: USB EHCI 1.00
USB5: USB OHCI 1.0
scanning bus 0 for devices... 1 USB Device(s) found
scanning bus 1 for devices... 1 USB Device(s) found
scanning bus 2 for devices... 1 USB Device(s) found
scanning bus 3 for devices... 1 USB Device(s) found
scanning bus 4 for devices... 1 USB Device(s) found
scanning bus 5 for devices... 1 USB Device(s) found
scanning usb for storage devices... 0 Storage Device(s) found
Device 0: unknown device
ethernet@fe300000 Waiting for PHY auto negotiation to complete......... TIMEOUT !
Could not initialize PHY ethernet@fe300000
missing environment variable: pxeuuid
missing environment variable: bootfile
Retrieving file: pxelinux.cfg/01-7a-1d-33-50-3d-a1
ethernet@fe300000 Waiting for PHY auto negotiation to complete..
......
// Eventually, the distro command fails to find firmware on all possible storage media and stops at the U-Boot command line.
=>