Introduction: Unlocking the RockPro64 with Coreboot for Android Go

The quest for open-source firmware and optimized performance on embedded systems often leads to Coreboot. While traditionally associated with PCs and Chromebooks, Coreboot’s minimalistic design makes it an ideal candidate for deeply customizing Single Board Computers (SBCs) running Android, particularly lightweight distributions like Android Go. This article delves into the intricate process of porting and flashing Coreboot onto the RockPro64, leveraging U-Boot as a payload to boot a high-performance Android Go ROM. This approach not only slashes boot times but also offers a transparent, auditable boot chain, enhancing security and giving developers unparalleled control over their hardware.

The RockPro64, with its powerful Rockchip RK3399 SoC, is a robust platform for such an endeavor. By replacing its proprietary boot firmware with Coreboot, we strip away unnecessary bloat, potentially improving resource utilization and providing a foundation for a truly optimized Android experience.

Prerequisites: Tools and Environment Setup

Embarking on this journey requires a combination of hardware tools, software environments, and a significant amount of patience. Ensure you have the following before proceeding:

• Hardware:
• RockPro64 board
• SPI programmer (e.g., Raspberry Pi configured as SPI programmer, or a dedicated CH341A programmer)
• SOIC8/SOP8 test clip (for connecting to the SPI flash chip)
• Jumper wires
• Soldering iron (optional, for direct soldering if clip fails or for desoldering)
• Development PC running Linux (Ubuntu/Debian recommended)
• USB-to-Serial TTL adapter (for console output)
• MicroSD card or eMMC module (for Android Go)
• Software:
• A Linux distribution (Ubuntu 20.04+ recommended)
• Git, GCC cross-compiler for AArch64 (aarch64-linux-gnu-gcc)
• build-essential, flex, bison, libncurses-dev, libftdi-dev, libusb-dev, flashrom
• Coreboot source code
• U-Boot source code
• Android Go AOSP source (or a pre-built compatible image for RK3399)

Setting Up the Development Environment

First, update your system and install the necessary build tools and libraries:

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential git flex bison libncurses-dev libftdi-dev libusb-dev python3 python3-dev python3-pip cmake automake libtool

Next, install the ARM64 cross-compiler. This is crucial for building firmware for the Rockchip RK3399:

sudo apt install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

Finally, clone the Coreboot and U-Boot repositories:

git clone https://review.coreboot.org/coreboot
cd coreboot
git submodule update --init --recursive
cd ..
git clone git://git.denx.de/u-boot.git

Identifying and Backing Up the Stock Firmware

This is arguably the most critical step. The RockPro64 features a serial (SPI) flash chip that stores the boot firmware. On most revisions, this is a Winbond 25Q128FV or similar, typically an 8-pin SOIC chip located near the RK3399 SoC. Carefully locate the chip and identify its pin 1 (usually marked with a dot).

Before attempting any writes, **always back up your original firmware**. Connect your SPI programmer to the RockPro64’s SPI flash chip using the SOIC8 clip. Ensure the RockPro64 is powered OFF during this process.

If using a Raspberry Pi as a programmer, enable SPI via `sudo raspi-config` and ensure `flashrom` is installed. Then, execute the backup:

sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=2000 -r original_rockpro64_firmware.rom

Store this `original_rockpro64_firmware.rom` file in a safe place. It’s your only way back if something goes wrong.

Building U-Boot as a Coreboot Payload

Coreboot’s primary function is to initialize the minimal hardware, primarily RAM and basic peripherals. For complex systems like the RK3399, it then hands off to a more feature-rich bootloader, often U-Boot, which handles device tree parsing, storage access, and loading the operating system kernel. We’ll build U-Boot specifically for the RockPro64:

cd u-boot
make distclean
make rk3399_rockpro64_defconfig
make CROSS_COMPILE=aarch64-linux-gnu- 

Upon successful compilation, you will find `u-boot.bin` in the U-Boot directory. This binary will serve as our Coreboot payload.

Configuring and Building Coreboot

Now, let’s configure Coreboot to support the RockPro64 and integrate our U-Boot payload:

cd ../coreboot
make menuconfig

Navigate through the menu with the following key selections:

• Mainboard:
• Mainboard -> Vendor -> Rockchip
• Mainboard -> Board Name -> RockPro64
• Chipset:
• Chipset -> Rockchip RK3399 (This should be automatically selected with the mainboard)
• Payload:
• Payload -> Add a custom payload (Enable this)
• Payload -> Path to custom payload: Enter the absolute path to your `u-boot.bin` (e.g., `/home/user/u-boot/u-boot.bin`)
• Payload -> Custom payload is a CBFS payload (Enable this)
• General Setup:
• General setup -> Coreboot verbose output (Enable for debugging)
• General setup -> Console output -> Sereal console (Enable serial console output for debugging)
• Memory Initialization:
• Coreboot for RK3399 typically relies on vendor-provided binary blobs (FSP or similar) for complex DDR initialization. Ensure the relevant binary blobs are correctly pulled and configured (Coreboot’s `git submodule update` usually handles this, but verify `config.log` during build if issues arise).

Save your configuration and exit `menuconfig`. Now, build Coreboot:

make CROSS_COMPILE=aarch64-linux-gnu-

A successful build will produce `build/coreboot.rom` in your `coreboot` directory. This is your custom Coreboot firmware image.

Flashing the Coreboot Firmware

With `coreboot.rom` in hand, it’s time to flash it to your RockPro64. Ensure the RockPro64 is still powered off and your SPI programmer is correctly connected to the SPI flash chip.

sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=2000 -w build/coreboot.rom

After flashing, it’s crucial to verify the write operation by reading the flash content back and comparing its checksum:

sudo flashrom -p linux_spi:dev=/dev/spidev0.0,spispeed=2000 -r new_coreboot_readback.rom
md5sum build/coreboot.rom new_coreboot_readback.rom

The MD5 sums should match exactly. If they don’t, DO NOT attempt to boot, and re-flash. A mismatch indicates a bad flash, which can brick your device.

Preparing and Booting Android Go

With Coreboot and U-Boot successfully flashed, the RockPro64 is ready for Android Go. You will need an Android Go AOSP image specifically compiled for the RK3399. This typically involves building the Android source with the appropriate device tree for the RockPro64.

Once you have your Android Go image (e.g., a `boot.img` and `system.img`), you’ll flash it to an eMMC module or a high-speed MicroSD card. The exact flashing procedure depends on the Android image’s format, but commonly involves `fastboot` if U-Boot is configured for it, or direct imaging to the storage device:

# Example for flashing to SD card (replace /dev/sdX with your SD card device)
sudo dd if=path/to/android_go_image.img of=/dev/sdX bs=4M status=progress

Insert the prepared storage medium into your RockPro64. Connect your USB-to-Serial adapter to the RockPro64’s serial console header and open a terminal emulator (e.g., `minicom`, `screen`) at 115200 baud.

Power on the RockPro64. You should first see Coreboot messages on the serial console, followed by U-Boot’s boot sequence. U-Boot will then detect your Android Go installation and proceed to load the kernel and ramdisk, initiating the Android boot process.

Troubleshooting Common Issues

• No output on serial console: Double-check serial connection, baud rate (115200), and Coreboot `menuconfig` settings for serial console.
• Flashrom errors: Verify SPI programmer connection, test clip seating, and RockPro64 power state (must be OFF). Ensure `flashrom` has correct permissions (`sudo`).
• U-Boot fails to load Android: This often points to issues with U-Boot’s environment variables, device tree, or the Android image itself. Verify the U-Boot console for error messages.
• Android boots, but crashes/freezes: This indicates an issue with the Android image, kernel, or device tree. Ensure compatibility with the RK3399 on the RockPro64.

Conclusion

Mastering Coreboot for your RockPro64 transforms it into an even more capable and transparent platform for Android Go. By replacing proprietary firmware with an open-source boot chain, you gain complete control, enhance security, and potentially achieve faster, more efficient boot times. This advanced customization opens doors for further optimizations, making your RockPro64 an excellent foundation for specialized embedded Android applications, kiosk systems, or a truly personalized mobile computing experience.