User:Brendlefly62/Rockchip RK3588S Rock 5c/Build-Install-U-Boot

This guide describes how to set up Das U-Boot bootloader for your ROCK 5c, using another arm64 device or on an amd64 crossdev platform, by building the bootloader firmware from upstream source code.

Warning
There are some options regarding how to build the u-boot bootloader, if that is desired --

As of 29 July 2024, the mainline upstream sources for u-boot and arm trusted firmware (ATF) do not support the rk3588 family of SOCs. Instead, this guide uses sources from https://gitlab.collabora.com/ as described also at this site.
However, while this "works" the author discovered that the Rock 5c system booted with the resulting u-boot had some crypto related cpu capabilities disabled and has since reverted to use of an Armbian-built u-boot as described in the tip below.

Tip
* It is also possible to skip all the work described below, if the armbian/build process was used to create an armbian system for this board. In this case, one can just retrieve the u-boot binaries produced by armbian and write them to new media using the dd command, as described in this other article.

Note
Acknowledgement: Inspiration for this article also came from similar work done for the PINE64 ROCKPro64 ==> https://wiki.gentoo.org/index.php?title=PINE64_ROCKPro64/Installing_U-Boot

Prerequisites

U-Boot can be built on an ARM64 device or cross-compiled on a PC. Regardless, we will need:

git, to check out the sources
dtc, to compile device trees
swig, to build U-Boot
crossdev, since both a 64- and 32-bit ARM toolchains are required

Make sure these are installed:

root #emerge --ask --update dev-vcs/git sys-apps/dtc dev-lang/swig sys-devel/crossdev

Please review the crossdev article if you don't already have it set up.

You may need to install the 32-bit toolchain, which is required to build code for Cortex-M0 MCUs in BL31:

root #crossdev --target arm-none-eabi

If cross-compiling, install the 64-bit cross-compiler toolchain:

root #crossdev --target aarch64-unknown-linux-gnu

Compiling

Create a workspace in which to build bootloader from sources

user $mkdir My_Rock5c_u-boot_project

user $cd My_Rock5c_u-boot_project

Rockchip Binary Toolkit (rkbin)

user $git clone https://gitlab.collabora.com/hardware-enablement/rockchip-3588/rkbin.git

Arm Trusted Firmware

Get the sources:

Note
As of 29 July 2024, mainline sources at https://github.com/ARM-software/arm-trusted-firmware.git do not support the rk3588 family of SOCs. Sources at https://gitlab.collabora.com are used here.

user $

git clone https://gitlab.collabora.com/hardware-enablement/rockchip-3588/trusted-firmware-a

user $

cd arm-trusted-firmware

user $

git tag

…

v2.9.0

Let's select the latest currently stable version:

user $git checkout v2.9.0

The repository contains a few binaries. If this is unacceptable, they may be deleted:

user $

git rm '*.bin'

for x in $(find ./ -iname *.bin); do rm -v $x; done

Create the bl31.elf file

To compile on ARM64, run:

user $make -j$(nproc) PLAT=rk3588 bl31

If cross-compiling, run:

user $make -j$(nproc) PLAT=rk3588 CROSS_COMPILE=aarch64-unknown-linux-gnu- bl31

If running distcc on the cross-compiling platform, it may be wise/necessary to disable that by temporarily removing '/usr/lib/distcc/bin' from your $PATH and turning off distcc in $FEATURES

user $export PATH=$(echo $PATH | sed 's|/usr/lib/distcc/bin:||')

user $

MAKEOPTS="-j$(nproc) -l$(nproc)" FEATURES=$FEATURES" -distcc -distcc-pump" PLAT=rk3588 CROSS_COMPILE=aarch64-unknown-linux-gnu- make bl31

Once finished, make a copy of resulting bl31.elf binary for safekeeping:

user $

mkdir ../rk3399-atf-2.9.0

user $

cp build/rk3399/release/bl31/bl31.elf ../rk3399-atf-2.9.0

Build U-Boot

Now we're ready to build U-Boot itself. Let's get the sources:

Note
As of 29 July 2024, mainline sources at https://source.denx.de/u-boot/u-boot.git do not support the rk3588 family of SOCs. Sources at https://gitlab.collabora.com are used here.

user $

git clone https://gitlab.collabora.com/hardware-enablement/rockchip-3588/u-boot

user $cd u-boot

At the time of this writing, this is v2024.01

Export variabled locating rkbin and atf files

Export variables pointing to the required files from rkbin and trusted-firmware-a

user $

export ROCKCHIP_TPL=../rkbin/bin/rk35/rk3588_ddr_lp4_2112MHz_lp5_2736MHz_v1.08.bin

user $

export BL31=../trusted-firmware-a/build/rk3588/release/bl31/bl31.elf

Identify and load board-specific default configuration. Note that the rock-5a defconfig is used here, because there isn't one available for 5c, and 5a is also based on the rk3588s SOC:

make defconfig

user $

find ./ -iname *rk3399*_defconfig

If not cross-compiling, format this make command in a manner similar to what was used to make the bl31 firmware, above.

make menuconfig

Similar to the Linux kernel, menuconfig can be used to make changes to the configuration. You probably don't need to make any changes.

{{Tip|See notes below about u-boot serial console baud rate setting before concluding this step is un-needed.

user $$make menuconfig

make

You probably won't need to make any other changes. Compile --

user $FEATURES=${FEATURES}" -distcc" make -j$(nproc) CROSS_COMPILE=aarch64-unknown-linux-gnu-

Installing

When powered on, Rock 4c Plus will attempt to find a bootloader in the following order:

Onboard 128MB SPI Flash - not present on 5c
Removable eMMC - empty connector, not populated by default on 5c
microSD card - i.e. this is the only real option for where to put u-boot
USB and NVMe are also options but are presently beyond the scope of this article

Once U-Boot is loaded, it could then be used to load the kernel from MMC or USB (or NVMe if provided via an external PCIe connector), or via the network. By default, after exhausting other options, u-boot will connect to the local network's dhpc server, looking for tftp service from which to retrieve a bootable image (this might be considered a security concern).

Installing on microSD/eMMC

Note
(note only, do not execute) The Rockchip community (http://opensource.rock-chips.com/wiki_Boot_option) instructs loading boot files at associated sectors of the eMMC/SD Card --

For miniloader boot option --
dd if=idbloader.img of=<device> seek=64
dd if=uboot.img of=<device> seek=16384
dd if=trust.img of=<device> seek=24576
dd if=boot.img of=<device> seek=32768
dd if=rootfs.img of=<device> seek=262144

For spl boot option --
dd if=idbloader.img of=sdb seek=64
dd if=u-boot.itb of=sdb seek=16384
dd if=boot.img of=sdb seek=32768
dd if=rootfs.img of=sdb seek=262144

Note that "boot.img" and "rootfs.img" may refer to packaged .img files installed as instructed above. However, this article describes a procedure for installing rootfs on a partition and /boot/ as a directory within the partition. It is important to understand the bootloader will hand off control from the bootloader to the kernel (or efi) according to instructions it finds when it transfers control to an acceptable boot scenario method found at the address specified above for "boot.img"

Note thus that the "boot.img" address refers to the boot partition/folder of the rootfs, wherein the boot.scr or extlinux/extlinux.conf and associated zImage, and .dtb file will reside (with optional initrd and/or optional grub.efi). The example in this article uses the boot.scr boot script method and assumes no grub.efi, and will append the rootfs information to kernel cli, etc.

Warning
* Note that uboot.img is written starting at sector 16384, and the scenario expects the boot.img (or the boot directory/partition) to be at sector 32768. If starting from scratch, make sure the microSD card is partitioned such that 32768 is the start address for the rootfs partition containing /boot/ (ext4 in this case), and there is no other file system installed below that sector.

Be sure to replace /dev/sdd with the correct device!

As root, enter the u-boot build directory, and write the images to the card.

root #

cd /path/to/u-boot

root #

dd if=idbloader.img of=/dev/sdd seek=64

root #

dd if=u-boot.itb of=/dev/sdd seek=16384

Serial console support established with USB-FTDI connection to GND and UART Tx/Rx (pins 6/8/10)(source)

Observing boot message with serial console

Before installing a Linux operating system, check to ensure that U-Boot is booting correctly. It may be possible to use a USB-to-TTL connector (such as this one or this one), though the author has found that those are not supported by Windows 11. Instead, the author used a mini-usb FTDI board such as are commonly used to program AVR microcontrollers that lack on-board USB support (see photo) and used PuTTy software on a Windows 11 desktop PC to monitor the serial console.

Connect the USB-TTL device to pins 6 (GND), 8 (UART2_TX) and 10 (UART2_RX) on the PI2 Bus (consult the Rock 4c Plus Hardware guide for reference) to see the early boot up messages:

root #screen /dev/ttyUSB0 1500000

Tip
* Make sure RX and TX are not backwards

Optional: Adapting baud rate

Serial communication usually requires both sides of the communication to agree on a common baud rate. By default, Rockchip uses 1500000 bauds, which may be too fast for common USB-to-serial adapters. As a consequence, you may not see any boot-messages from u-boot. A much more common and widely supported, but slower baud rate is 115200 bauds. U-Boot can be configured to use this slower baud rate.

Use menuconfig as described in #Build_U-Boot and reconfigure the symbol BAUDRATE to 115200. Rebuild u-boot and copy it to the SD-card. Now start your program of choice for serial communication

Linux PC as external serial console

root #screen /dev/ttyUSB0 115200

Window s PC for external serial console

Output

Note
* Early output from U-Boot TPL/SPL won't be shown on HDMI, only on serial

You can press a key to interrupt the boot process and enter U-Boot's interactive shell
You can find the list of commands and their syntax if you run help

Booting a custom-built u-boot

Now that U-Boot installed on the SD card, the next step is to test-boot it in a live system.

By default, U-Boot scans the partitions of each device (except SATA, see next section) to find something it knows how to load. The default supported file systems are ext2, ext4 and FAT, but there are a few others you can enable in U-Boot's menuconfig. You will want your /boot partition to be formatted with one of those filesystems.

Creating boot.scr

One way it can boot is to find and execute a boot script boot.scr, which will contain commands for U-Boot to execute, using a uEnv.txt file to allow user-configuration of some variables without the need to recompile the boot script each time a modification is made. These files will be in the /boot partition along with (eventually) the kernel and device tree binary.

First, create a file boot.cmd. The example below includes a lot of extra stuff to facilitate exploration and debugging, but it can be significantly simplified --

CODE boot.cmd

echo "Loaded and running boot.scr!"
#setenv userEnv "joetooEnv.txt"

# defaults
setenv load_addr "0x9000000"
setenv overlay_error "false"
setenv rootdev "/dev/mmcblk0p1"
setenv verbosity "1"
setenv console "both"
setenv bootlogo "false"
setenv rootfstype "ext4"
if test -z "$bootargs"; then
    setenv bootargs root=${rootdev} rootdelay=5
fi

# print some debugging info
echo "-----[ Initial State ]-----------------------------------"
#echo "userEnv..........: "${userEnv}
echo "load_addr........: "${load_addr}
echo "filesize.........: "${filesize}
echo "rootdev..........: "${rootdev}
echo "devtype..........: "${devtype}
echo "devnum...........: "${devnum}
echo "prefix...........: "${prefix}
echo "distro_bootpart..: "${distro_bootpart}
echo "verbosity........: "${verbosity}
echo "console..........: "${console}
echo "consoleargs......: "${consoleargs}
echo "bootlogo.........: "${bootlogo}
echo "rootfstype.......: "${rootfstype}
echo "earlycon.........: "${earlycon}
echo "overlays.........: "${overlays}
echo "overlay_prefix...: "${overlay_prefix}
echo "fdtfile..........: "${fdtfile}
echo "fdt_addr_r.......: "${fdt_addr_r}
echo "imagefile........: "${imagefile}
echo "kernel_addr_r....: "${kernel_addr_r}
echo "initrdfile.......: "${initrdfile}
echo "ramdisk_addr_r...: "${ramdisk_addr_r}
echo "partuuid.........: "${partuuid}
echo "usbstoragequirks.: "${usbstoragequirks}
echo "extraargs........: "${extraargs}
echo "extraboardargs...: "${extraboardargs}
echo "bootargs.........: "${bootargs}
echo "--------------------------------------------------------"

# Override/overwrite defaults per user's environment selections
echo "Ok - I am about to try reading joetooEnv.txt..."
if test -e ${devtype} ${devnum} ${prefix}joetooEnv.txt; then
        load ${devtype} ${devnum} ${load_addr} ${prefix}joetooEnv.txt
        env import -t ${load_addr} ${filesize}
else
	echo "Did not find or load joetooEnv.txt"
fi

# Manage console settings
if test "${console}" = "display" || test "${console}" = "both"; then setenv consoleargs "console=tty1"; fi
if test "${console}" = "serial" || test "${console}" = "both"; then setenv consoleargs "console=ttyS2,115200 ${consoleargs}"; fi
if test "${earlycon}" = "on"; then setenv consoleargs "earlycon ${consoleargs}"; fi
if test "${bootlogo}" = "true"; then
        setenv consoleargs "splash plymouth.ignore-serial-consoles ${consoleargs}"
else
        setenv consoleargs "splash=verbose ${consoleargs}"
fi

# get PARTUUID of first partition on SD/eMMC the boot script was loaded from
if test "${devtype}" = "mmc"; then part uuid mmc ${devnum}:1 partuuid; fi

# update bootargs
#setenv bootargs "root=${rootdev} rootwait rootfstype=${rootfstype} ${consoleargs} consoleblank=0 loglevel=${verbosity} ubootpart=${partuuid} usb-storage.quirks=${usbstoragequirks} ${extraargs} ${extraboardargs}"
setenv bootargs "root=${rootdev} rootwait rootfstype=${rootfstype} ${consoleargs} consoleblank=0 loglevel=${verbosity} usb-storage.quirks=${usbstoragequirks} ${extraargs} ${extraboardargs}"

echo "-----[ Potentially Updated State ]-----------------------"
#echo "userEnv..........: "${userEnv}
echo "load_addr........: "${load_addr}
echo "filesize.........: "${filesize}
echo "rootdev..........: "${rootdev}
echo "devtype..........: "${devtype}
echo "devnum...........: "${devnum}
echo "prefix...........: "${prefix}
echo "distro_bootpart..: "${distro_bootpart}
echo "verbosity........: "${verbosity}
echo "console..........: "${console}
echo "consoleargs......: "${consoleargs}
echo "bootlogo.........: "${bootlogo}
echo "rootfstype.......: "${rootfstype}
echo "earlycon.........: "${earlycon}
echo "overlays.........: "${overlays}
echo "overlay_prefix...: "${overlay_prefix}
echo "fdtfile..........: "${fdtfile}
echo "fdt_addr_r.......: "${fdt_addr_r}
echo "imagefile........: "${imagefile}
echo "kernel_addr_r....: "${kernel_addr_r}
echo "initrdfile.......: "${initrdfile}
echo "ramdisk_addr_r...: "${ramdisk_addr_r}
echo "partuuid.........: "${partuuid}
echo "usbstoragequirks.: "${usbstoragequirks}
echo "extraargs........: "${extraargs}
echo "extraboardargs...: "${extraboardargs}
echo "bootargs.........: "${bootargs}
echo "-----[ now env print -a ]---------------------------------"
env print -a

# Load device tree file and kernel (to do: initramfs option)

# device tree - note that it finds the file in the "dtb" directory
echo "Loading device tree from ${devtype} ${devnum}:${distro_bootpart}..."
load ${devtype} ${devnum}:${distro_bootpart} ${fdt_addr_r} ${prefix}dtb/${overlay_prefix}/${fdtfile}

echo "Loading initrd from ${devtype} ${devnum}:${distro_bootpart}..."
load ${devtype} ${devnum} ${ramdisk_addr_r} ${prefix}${initrdfile}

echo "Loading kernel from ${devtype} ${devnum}:${distro_bootpart}..."
load ${devtype} ${devnum}:${distro_bootpart} ${kernel_addr_r} ${prefix}${imagefile}
# Load overlays (to do, if needed)

# Boot!
echo "Booting with arguments: ${bootargs}"
#booti ${kernel_addr_r} - ${fdt_addr_r}
booti ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}

# Recompile instruction 
# 
# Cross-compiling:
# cd to u-boot directory holding boot.cmd and run
# mkimage -C none -A arm64 -T script -d boot.cmd boot.scr
# then copy boot.scr, boot.cmd, and joetooEnv.txt to the /boot partition
# of your target system eMMC or microSD card
#
# If modifying an existing system (from said system)
# mkimage -C none -A arm64 -T script -d /boot/boot.cmd /boot/boot.scr

CODE joetooEnv.txt

verbosity=6
earlycon=on
bootlogo=true
overlay_prefix=rockchip
fdtfile=rk3399-rock-pi-4c-plus.dtb
imagefile=vmlinuz
initrdfile=uInitrd
rootdev=PARTUUID=5f185faf-01
rootfstype=ext4
extraargs=init=/sbin/init
usbstoragequirks=0x2537:0x1066:u,0x2537:0x1068:u

Important
Be sure to change rootdev= to point to your actual root partition! This can by done by PARTUUID= as in this example, more portably than by path to block device, like "/dev/mmcblk0p1" or by LABEL=-- but either way is valid. Note however, that boot.cmd, compiled to boot.scr must pass the associated parameter on the kernel command line, so that it can be referenced in userspace. For the author, trial and error

Then, compile it to boot.scr:

root #mkimage -C none -A arm64 -T script -d boot.cmd boot.scr

Tip
* mkimage can be used from either the bin directory in your U-Boot build directory or from dev-embedded/u-boot-tools

Create a Makefile or a shell script so you don't have to look up the command above next time you need to edit

If the /boot partition is on microSD, it should work without additional steps, and the output will look something like this--

Expected boot messages

Now put the card into the device and power on. If successful, you should be able to see output like this (click to expand):

DDR Version V1.08 20220617
LPDDR4X, 2112MHz
channel[0] BW=16 Col=10 Bk=8 CS0 Row=17 CS1 Row=17 CS=2 Die BW=8 Size=4096MB
channel[1] BW=16 Col=10 Bk=8 CS0 Row=17 CS1 Row=17 CS=2 Die BW=8 Size=4096MB
channel[2] BW=16 Col=10 Bk=8 CS0 Row=17 CS1 Row=17 CS=2 Die BW=8 Size=4096MB
channel[3] BW=16 Col=10 Bk=8 CS0 Row=17 CS1 Row=17 CS=2 Die BW=8 Size=4096MB
Manufacturer ID:0x6
CH0 RX Vref:32.7%, TX Vref:23.8%,22.8%
CH1 RX Vref:31.7%, TX Vref:22.8%,21.8%
CH2 RX Vref:30.7%, TX Vref:21.8%,21.8%
CH3 RX Vref:30.7%, TX Vref:20.8%,21.8%
change to F1: 528MHz
change to F2: 1068MHz
change to F3: 1560MHz
change to F0: 2112MHz
out

U-Boot SPL 2024.01-g889c316b59 (Jul 29 2024 - 15:07:46 -0400)
Trying to boot from MMC2
## Checking hash(es) for config config-1 ... OK
## Checking hash(es) for Image atf-1 ... sha256+ OK
## Checking hash(es) for Image u-boot ... sha256+ OK
## Checking hash(es) for Image fdt-1 ... sha256+ OK
## Checking hash(es) for Image atf-2 ... sha256+ OK
NOTICE:  BL31: v2.10.0  (release):002d8e85c
NOTICE:  BL31: Built : 15:00:28, Jul 29 2024


U-Boot 2024.01-g889c316b59 (Jul 29 2024 - 15:07:46 -0400)

Model: Radxa ROCK 5 Model A
DRAM:  16 GiB (effective 15.7 GiB)
Core:  320 devices, 27 uclasses, devicetree: separate
MMC:   mmc@fe2c0000: 1, mmc@fe2e0000: 0
Loading Environment from nowhere... OK
In:    serial@feb50000
Out:   serial@feb50000
Err:   serial@feb50000
Model: Radxa ROCK 5 Model A
Net:   eth0: ethernet@fe1c0000
Hit any key to stop autoboot:  0
** Booting bootflow 'mmc@fe2c0000.bootdev.part_1' with script
Loaded and running boot.scr!
Boot script loaded from mmc 1:1
-----[ Initial State ]-----------------------------------
load_addr........: 0x9000000
filesize.........:
rootdev..........: /dev/mmcblk0p1
devtype..........: mmc
devnum...........: 1
prefix...........: /boot/
distro_bootpart..: 1
verbosity........: 1
console..........: both
consoleargs......:
consolebaud......:
logo.............:
bootlogo.........: false
rootfstype.......: ext4
arch.............: arm
earlycon.........: off
overlays.........:
overlay_dir......:
overlay_prefix...:
dtb_prefix.......:
user_overlays....:
fdtfile..........: rockchip/rk3588s-rock-5a.dtb
fdt_addr_r.......: 0x0a100000
imagefile........:
kernel_addr_r....: 0x02080000
initrdfile.......:
ramdisk_addr_r...: 0x0a200000
partuuid.........:
usbstoragequirks.:
extraargs........:
extraboardargs...:
bootargs.........: root=/dev/mmcblk0p1 rootdelay=5
--------------------------------------------------------
Ok - I am about to try reading joetooEnv.txt...
641 bytes read in 6 ms (103.5 KiB/s)
-----[ Potentially Updated State ]-----------------------
load_addr........: 0x9000000
filesize.........: 281
rootdev..........: UUID=8305eee2-1f6c-4b84-abe6-e74c386a6704
devtype..........: mmc
devnum...........: 1
prefix...........: /boot/
distro_bootpart..: 1
verbosity........: 6
console..........: both
consoleargs......: splash=verbose earlycon console=tty1 console=ttyS2,1500000n8
consolebaud......: 1500000
logo.............:
bootlogo.........: false
rootfstype.......: ext4
arch.............: arm64
earlycon.........: on
overlays.........:
overlay_dir......: rockchip/overlay
overlay_prefix...: rockchip-rk3588
dtb_prefix.......: rockchip
user_overlays....:
fdtfile..........: rk3588s-rock-5c.dtb
fdt_addr_r.......: 0x0a100000
imagefile........: Image
kernel_addr_r....: 0x02080000
initrdfile.......: uInitrd
ramdisk_addr_r...: 0x0a200000
partuuid.........: 00000000-01
usbstoragequirks.: 0x2537:0x1066:u,0x2537:0x1068:u
extraargs........: coherent_pool=2M init=/usr/bin/init selinux=0 net.ifnames=0 debug
extraboardargs...:
bootargs.........: root=UUID=8305eee2-1f6c-4b84-abe6-e74c386a6704 rootdelay=5 rootwait rootfstype=ext4 splash=verbose earlycon console=tty1 console=ttyS2,1500000n8 consoleblank=0 loglevel=6 usb-storage.quirks=0x2537:0x1066:u,0x2537:0x1068:u coherent_pool=2M init=/usr/bin/init selinux=0 net.ifnames=0 debug
-----[ now env print -a ]---------------------------------
arch=arm64
baudrate=1500000
board=rock5a-rk3588s
board_name=rock5a-rk3588s
boot_targets=mmc1 mmc0 nvme scsi usb pxe dhcp spi
bootargs=root=UUID=8305eee2-1f6c-4b84-abe6-e74c386a6704 rootdelay=5 rootwait rootfstype=ext4 splash=verbose earlycon console=tty1 console=ttyS2,1500000n8 consoleblank=0 loglevel=6 usb-storage.quirks=0x2537:0x1066:u,0x2537:0x1068:u coherent_pool=2M init=/usr/bin/init selinux=0 net.ifnames=0 debug
bootcmd=bootflow scan
bootdelay=2
bootlogo=false
console=both
consoleargs=splash=verbose earlycon console=tty1 console=ttyS2,1500000n8
consolebaud=1500000
cpu=armv8
cpuid#=4132584b5a0000000000000000070e15
devnum=1
devtype=mmc
dfu_alt_info=ram ram0=ram ram 0x0 CONFIG_SYS_DFU_DATA_BUF_SIZE
dfu_alt_info_ram=u-boot.itb ram 0x0 CONFIG_SYS_DFU_DATA_BUF_SIZE
distro_bootpart=1
dtb_prefix=rockchip
earlycon=on
ethaddr=ca:d7:51:05:71:ba
extraargs=coherent_pool=2M init=/usr/bin/init selinux=0 net.ifnames=0 debug
fdt_addr_r=0x0a100000
fdtcontroladdr=edef3420
fdtfile=rk3588s-rock-5c.dtb
fdtoverlay_addr_r=0x02000000
fileaddr=9000000
filesize=281
imagefile=Image
initrdfile=uInitrd
kernel_addr_r=0x02080000
kernel_comp_addr_r=0x08000000
kernel_comp_size=0x2000000
load_addr=0x9000000
loadaddr=0xc00800
overlay_dir=rockchip/overlay
overlay_error=false
overlay_prefix=rockchip-rk3588
partitions=uuid_disk=${uuid_gpt_disk};name=loader1,start=32K,size=4000K,uuid=${uuid_gpt_loader1};name=loader2,start=8MB,size=4MB,uuid=${uuid_gpt_loader2};name=trust,size=4M,uuid=${uuid_gpt_atf};name=boot,size=112M,bootable,uuid=${uuid_gpt_boot};name=rootfs,size=-,uuid=B921B045-1DF0-41C3-AF44-4C6F280D3FAE;
partuuid=00000000-01
prefix=/boot/
pxefile_addr_r=0x00e00000
ramdisk_addr_r=0x0a200000
rootdev=UUID=8305eee2-1f6c-4b84-abe6-e74c386a6704
rootfstype=ext4
script_offset_f=0xffe000
script_size_f=0x2000
scriptaddr=0x00c00000
serial#=d99cc271a37807af
soc=rk3588
stderr=serial@feb50000
stdin=serial@feb50000
stdout=serial@feb50000
usbstoragequirks=0x2537:0x1066:u,0x2537:0x1068:u
vendor=radxa
verbosity=6

Environment size: 2004/126972 bytes
Loading device tree from mmc 1:1...
148152 bytes read in 20 ms (7.1 MiB/s)
Loading initrd from mmc 1:1...
Failed to load '/boot/uInitrd'
Loading kernel from mmc 1:1...
Failed to load '/boot/Image'
Working FDT set to a100000
No overlay_error. Now trying to load fixup scripts...
could not find to load fixup script /boot/dtb/rockchip/overlay/rockchip-rk3588-fixup.scr. Skipping...
could not find to load fixup script /boot/fixup.scr. Skipping...
Booting with arguments: root=UUID=8305eee2-1f6c-4b84-abe6-e74c386a6704 rootdelay=5 rootwait rootfstype=ext4 splash=verbose earlycon console=tty1 console=ttyS2,1500000n8 consoleblank=0 loglevel=6 usb-storage.quirks=0x2537:0x1066:u,0x2537:0x1068:u coherent_pool=2M init=/usr/bin/init selinux=0 net.ifnames=0 debug

imagefile: Image

booting uncompressed kernel image [Image] ...
Bad Linux ARM64 Image magic!
Boot failed (err=-14)
Card did not respond to voltage select! : -110
Bus usb@fc800000: USB EHCI 1.00
Bus usb@fc840000: USB OHCI 1.0
Bus usb@fc880000: USB EHCI 1.00
Bus usb@fc8c0000: USB OHCI 1.0
scanning bus usb@fc800000 for devices... 3 USB Device(s) found
scanning bus usb@fc840000 for devices... 1 USB Device(s) found
scanning bus usb@fc880000 for devices... 1 USB Device(s) found
scanning bus usb@fc8c0000 for devices... 1 USB Device(s) found
ethernet@fe1c0000 Waiting for PHY auto negotiation to complete......... TIMEOUT !
phy_startup() failed: -110FAILED: -110ethernet@fe1c0000 Waiting for PHY auto negotiation to complete......... TIMEOUT !
phy_startup() failed: -110FAILED: -110=>

External resources

Return

Return to User:Brendlefly62/Radxa_ROCK_5C