Buildroot with Raspberry Pi - U-Boot

Raspberry Pi has a fairly complicated boot process with two bootloaders. The first one resides in built-in ROM and is responsible for starting the GPU. The GPU executes bootcode.bin, the second bootloader, which in the end runs the kernel. Although, there is a possibility to have the root file system booted from network with the stock firmware (actually the kernel allows that), lets look at an interesting alternative. I will use U-Boot, and show how to step by step migrate to a more customizable bootloader.

Check how to start with Buildroot and Raspberry Pi first.

Use Buildroot to compile U-Boot:

$ make nconfig

Go to Bootloaders and select U-Boot. U-Boot board name shows up, and needs to be set to rpi. After exiting config, run:

$ make all

After compiling, Buildroot puts u-boot.bin in output/images. Now the SD card needs to be mounted and the U-Boot binary should be copied to boot partition. Also, in config.txt, which is also on the boot partition, change:




Powering up the RPi with serial console attached gives this result:

U-Boot 2016.01 (Apr 09 2016 - 14:55:52 +0200)

DRAM:  412 MiB
RPI Model B rev2 (0xe)
MMC:   bcm2835_sdhci: 0
reading uboot.env

** Unable to read "uboot.env" from mmc0:1 **
Using default environment

In:    serial
Out:   lcd
Err:   lcd
Net:   Net Initialization Skipped
No ethernet found.
Hit any key to stop autoboot:  0 

U-Boot waits 3 seconds for the user to interrupt the autoboot. After that it will either search for a start script or try to setup network interfaces and boot from network. Interrupting the autoboot will give access to command line interface. In order to boot Linux, the following needs to be done:

mmc dev 0
fatload mmc 0:1 ${kernel_addr_r} zImage
fatload mmc 0:1 ${fdt_addr_r} bcm2708-rpi-b.dtb
setenv bootargs console=ttyAMA0,115200 root=/dev/mmcblk0p2 rootwait
bootz ${kernel_addr_r} - ${fdt_addr_r}

What is going on here is that first a switch to proper memory card is made. Then, the zImage (kernel) and device tree blob are loaded from flash to memory at addresses represented by kernel___addr___r and fdt___addr___r variables. Next, kernel boot arguments are set. bootz command starts the kernel. It actually needs three arguments, but for now the second argument is omitted with a hyphen, because it's not mandatory. After that, Linux is up and running.

Of course, typing those commands every time is pointless, so a startup script can be created. The above commands need to be put in a script named boot.scr and compiled into U-Boot image with:

$ mkimage -A arm -O linux -T script -C none -n boot.scr -d boot.scr boot.scr.uimg

Note! mkimage is a part of u-boot-tools available in Ubuntu

boot.scr.uimg should be copied to boot partition on SD card. U-Boot searches for a script with this name, and executes the compiled commands.


Now that U-Boot is ready, lets force the kernel to use an in-memory root file system. Again, this can be achieved by changing Buildroot configuration:

$ make nconfig

Go to Filesystem images, check cpio the root filesystem and choose gzip as Compression method. Also Create U-Boot image of the root filesystem needs to be checked. Run make all and copy the rootfs.cpio.uboot from output/images to boot partition.

Now, boot.scr needs to be altered:

mmc dev 0
fatload mmc 0:1 ${kernel_addr_r} zImage
fatload mmc 0:1 ${fdt_addr_r} bcm2708-rpi-b.dtb
fatload mmc 0:1 ${ramdisk_addr_r} rootfs.cpio.uboot
setenv bootargs console=ttyAMA0,115200
bootz ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}

Linux will not use the rootfs from mmcblk0p2, instead it will initialize the root file system from the rootfs.cpio.uboot image provided. Note that any changes made in runtime will be lost on reboot, since ramfs does not update the image.

Using initramfs is especially handy, when you care about the lifetime of the memory card. Now all reads and writes are done in-memory, and flash is used only at boot time.

Now the second partition can be erased:

$ sudo fdisk /dev/mmcblk0
d - delete partition
2 - second partition
n - create partition
p - primary
2 - partition number
first sector: default
last sector: default
w - write

Create file system:

$ sudo mkfs.ext4 /dev/mmcblk0p2

Data partition can be mounted on RPi:

# mkdir /mnt/sdcard
# mount /dev/mmcblk0p2 /mnt/sdcard
tftp boot

To simplify the process of loading new kernels and rootfs', instead of copying them to the SD card, and moving it back and forth, U-Boot allows to setup full network boot using tftp.

To achive this the machine serving the images needs to have a dhcp and tftp server running. Fortunately, dnsmasq provides both. It is available in every Linux distribution, so installing it is easy. Configuration can be found in /etc/dnsmasq.conf and it should be as follows:


You can choose the interface and IP ranges served by dhcp. Also a path to a directory, where images will be stored, needs to be specified.

After copying zImage, rootfs.cpio and bcm2708-rpi-b.dtb to /var/ftpd, use U-Boot to fetch those images:

usb start  
dhcp ${kernel_addr_r} zImage  
tftp ${fdt_addr_r} bcm2708-rpi-b.dtb  
tftp ${ramdisk_addr_r} rootfs.cpio.uboot  
setenv bootargs console=ttyAMA0,115200  
bootz ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}

USB needs to be started first, as it turns out that RPi has a network card which is a USB device. zImage is downloaded after dhcp client acquires an IP address. Device tree blob and rootfs are downloaded with tftp, as U-Boots already has the IP.

We can even prepare multiple scripts, one for downloading and storing the images on SD card and, second one, the default, to always boot what can be found on the card


mmc dev 0  
fatload mmc 0:1 ${kernel_addr_r} zImage  
fatload mmc 0:1 ${fdt_addr_r} bcm2708-rpi-b.dtb  
fatload mmc 0:1 ${ramdisk_addr_r} rootfs.cpio.uboot  
setenv bootargs console=ttyAMA0,115200  
bootz ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}  


usb start  
dhcp ${kernel_addr_r} zImage
fatwrite mmc 0:1 ${fileaddr} zImage ${filesize}
tftp ${fdt_addr_r} bcm2708-rpi-b.dtb
fatwrite mmc 0:1 ${fileaddr} bcm2708-rpi-b.dtb ${filesize}
tftp ${ramdisk_addr_r} rootfs.cpio.uboot
fatwrite mmc 0:1 ${fileaddr} rootfs.cpio.uboot ${filesize}
setenv bootargs console=ttyAMA0,115200  
bootz ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}
$ mkimage -A arm -O linux -T script -C none -n boot.scr -d boot.scr boot.scr.uimg
$ mkimage -A arm -O linux -T script -C none -n update.scr -d update.scr update.scr.uimg

Scripts themselves can also be downloaded via tftp:

usb start
dhcp ${scriptaddr} update.scr.uimg
source ${scriptaddr}

source command runs the script.

To sum up, U-Boot gives a lot of options to boot the RPi. Besides the ones I showed, one can also perform U-Boot update or write sophisticated scripts to decide how to perform the boot process, which is especially handy during development.