Forem: Paulo Fylippe Sell

Monitoring and Controlling CPU Temperature on Linux Systems Using Sysfs

Paulo Fylippe Sell — Sat, 19 Apr 2025 14:49:52 +0000

Effectively monitoring and managing CPU temperature in embedded systems is crucial to prevent throttling and ensure reliable device performance. The Raspberry Pi 5 features a built-in thermal sensor within its BCM2712 SoC, allowing real-time monitoring of the CPU core temperature. To help manage heat, an active cooler can be used, which typically activates once the CPU reaches a predefined temperature threshold. This article outlines the steps to enable both the thermal sensor and an active cooling system for monitoring and controlling the temperature on a Raspberry Pi 5 board using Buildroot to build the system.

Enabling the thermal sensor

The thermal sensor on the Raspberry Pi 5 is part of the Adaptive Voltage Scaling (AVS) system, which dynamically adjusts the CPU voltage based on workload and temperature. This mechanism helps reduce both power consumption and heat generation. The sensor is defined in the default Device Tree Source (DTS) file bcm2712.dtsi found in the Raspberry Pi's Linux Kernel repository. The relevant section is shown below:

avs_monitor: avs-monitor@7d542000 {
    compatible = "brcm,bcm2711-avs-monitor",
                    "syscon", "simple-mfd";
    reg = <0x7d542000 0xf00>;
    status = "okay";

    thermal: thermal {
        compatible = "brcm,bcm2711-thermal";
        #thermal-sensor-cells = <0>;
    };
};

The device drivers required to enable the thermal sensors listed below are typically included in the default Linux kernel configuration for the Raspberry Pi 5.

CONFIG_BCM2711_THERMAL=y
CONFIG_MFD_SYSCON=y

Enabling the active cooler

The Raspberry Pi 5 supports an active cooler device that can be connected through a 4-pin a PWM header located on the board’s surface.

The cooler is described in the bcm2712-rpi-5-b.dtsi DTS file as following:

fan: cooling_fan {
    status = "okay";
    compatible = "pwm-fan";
    #cooling-cells = <2>;
    cooling-min-state = <0>;
    cooling-max-state = <3>;
    cooling-levels = <0 75 125 175 250>;
    pwms = <&rp1_pwm1 3 41566 PWM_POLARITY_INVERTED>;
    rpm-regmap = <&rp1_pwm1>;
    rpm-offset = <0x3c>;
};

By default, the cooling_fan entry status is disabled, make sure to enable it. Also, make sure to enable the rp1_pwm1 entry in the same DTS file, as follows:

&rp1_pwm1 {
    status = "okay";
    pinctrl-0 = <&rp1_pwm1_gpio45>;
    pinctrl-names = "default";
};

The cooling device can be managed by the generic pwm-fan driver. The following options should be set in the Linux Kernel configuration to enable the feature:

CONFIG_PWM_RP1=y
CONFIG_SENSORS_PWM_FAN=m

Buildroot configuration

In one of my previous posts, I walked through the process of downloading and setting up the Buildroot build system.

Assuming that Buildroot 2014-11-1 was installed in /var folder, the image can be built as follows:

Assuming Buildroot 2024.11.1 was installed in the /var directory, the image for the Raspberry Pi 5 can be built with the following commands:

mkdir output && cd output
make O=$PWD -C /var/buildroot-2024.11.1 raspberrypi5_defconfig
make

After the build process completes, the resulting image can be written to an SD card using the dd command:

dd if=output/images/sdcard.img of=/dev/sda status=progress

Double-check the target device (/dev/sda) before running dd, as using the wrong device can overwrite critical data.

Monitoring the temperature via `sysfs`

Once the Raspberry Pi 5 has booted, the system's temperature can be monitored through the sysfs interface, which exposes thermal sensor data managed by the Kernel's thermal subsystem.

The device driver responsible for managing the active cooler dynamically adjusts the fan speed based on the system’s temperature. Once the pwm-fan module is loaded, it automatically regulates the fan according to the thermal zones defined in the device tree.

The current fan state can be also monitored via the sysfs interface.

The value returned corresponds to the current cooling level, which maps to predefined PWM values in the device tree, according to the current CPU temperature (in Celsius):

Cooling State	PWM Duty Cycle	Current Temperature
0	0	< 50
1	75	50 < current temperature < 60
2	125	60 < current temperature < 67.5
3	175	67.5 < current temperature < 75
4	250	> 75

The active fan can also be controlled from user space by disabling the Kernel module and directly interacting with the PWM sysfs interface. To begin, export PWM channel 3 by writing its index to /sys/class/pwm/pwmchip2/export. Once exported, the fan control interface becomes available at /sys/class/pwm/pwmchip2/pwm3/.

The image below demonstrates how to enable the device and run the fan at full speed:

Conclusion

Effective thermal management is essential in embedded Linux systems like the Raspberry Pi 5 to maintain performance and hardware longevity. By enabling the onboard thermal sensor and configuring the active cooler through Device Tree and Kernel options, you can build a responsive and reliable temperature control system.

Using Buildroot, integrating these features into a custom Linux image becomes a streamlined and repeatable process. Whether you choose to rely on automatic thermal zones or prefer manual control via the sysfs interface, you have full flexibility to tailor the cooling behavior to your application’s needs.

For an even more automated solution, check out this project, which reads the current temperature and dynamically adjusts the fan speed. If you’d like help integrating it into your Buildroot setup, feel free to reach out.

Enabling Raspberry Pi 5 Onboard Wi-Fi using Buildroot External Tree

Paulo Fylippe Sell — Sat, 12 Apr 2025 20:36:07 +0000

The Raspberry Pi 5 features a built-in wireless module based on the Cypress CYW43455, which connects to the main processor via an SDIO interface. This hardware provides wireless capabilities that make the WLAN interface one of the board’s most powerful and versatile features. It supports a wide range of use cases, from remote monitoring systems and IoT applications to portable media centers and wireless networking setups.

When designing a device that needs to connect to the internet (WAN) or operate within a local network (LAN), the onboard Wi-Fi removes the need for Ethernet cables, resulting in a cleaner and more flexible setup—especially valuable in constrained spaces or field deployments where wiring is impractical.

This post walks through the process of setting up a br2-external tree and enabling the Raspberry Pi 5’s WLAN interface from scratch using Buildroot, allowing developers to fully leverage wireless networking in embedded projects.

Buildroot External Tree

As work with Buildroot progresses, it becomes increasingly beneficial to take advantage of its customization capabilities. One powerful approach is to use a Buildroot External Tree. By setting up an external tree directory, custom board configurations and packages are kept separate from the core Buildroot source. This aligns with the recommended development architecture and makes it significantly easier to switch between different Buildroot versions without losing customizations. It streamlines version upgrades, improves maintainability, and encourages a cleaner, modular development workflow.

Recommended directory structure

The Buildroot official documentation recommends the following structure for storing board-specific customizations. When placed outside the main Buildroot source tree, this is referred to as a br2-external tree.

+-- board/
|       +-- <boardname>/
|           +-- linux.config
|           +-- busybox.config
|           +-- <other configuration files>
|           +-- post_build.sh
|           +-- post_image.sh
|           +-- rootfs_overlay/
|           |   +-- etc/
|           |   +-- <some files>
|           +-- patches/
|               +-- foo/
|               |   +-- <some patches>
|               +-- libbar/
|                   +-- <some other patches>
|
+-- configs/
|   +-- <boardname>_defconfig
|
+-- package/
|       +-- package1/
|       |    +-- Config.in
|       |    +-- package1.mk
|       +-- package2/
|           +-- Config.in
|           +-- package2.mk
|
+-- Config.in
+-- external.mk
+-- external.desc

A valid br2-external tree must include at least three essential files, which define the external tree and its customizations:

external.desc
external.mk
Config.in

The external.desc file contains metadata about the br2-external tree and is required for Buildroot to properly recognize and integrate the external directory. It supports two keywords:

name (mandatory): defines the name of the external tree. Buildroot uses this to create a variable called BR2_EXTERNAL_$(NAME)_PATH, which holds the absolute path to the external tree. The name must consist of ASCII characters only.
desc (optional): provides a short description (recommended a maximum of 40 characters) for the external tree. This description is available within Buildroot as the variable BR2_EXTERNAL_$(NAME)_DESC.

To create a basic br2-external tree in the home folder and define its external.desc file, the following can be used:

mkdir ~/br2-external-tree
echo "name: DEV_TO_TREE" > ~/br2-external-tree/external.desc

external.mk file includes the Makefiles of all custom packages so that Buildroot knows how to build them. This file can be created by running:

cat > ~/br2-external-tree/external.mk << 'EOF'
include $(sort $(wildcard $(BR2_EXTERNAL_DEV_TO_TREE_PATH)/package/*/*.mk))
EOF

Note: BR2_EXTERNAL_DEV_TO_TREE_PATH refers to the name set in external.desc file earlier.

Config.in file declares the configuration options for custom packages, allowing them to appear in Buildroot’s menuconfig interface. A typical Config.in might look like this:

source "$BR2_EXTERNAL_DEV_TO_TREE_PATH/package/package1/Config.in"
source "$BR2_EXTERNAL_DEV_TO_TREE_PATH/package/package2/Config.in"

For now, an empty file will do the job, as we will come back to it later:

touch ~/br2-external-tree/Config.in

Build Configuration for Raspberry Pi 5

With the basis of the br2-external tree set, the next objective is to configure Builroot building system, using the default configuration for Rasberry Pi 5 board and passing the br2-external tree path in BR2_EXTERNAL variable (refer to this post to check on how to download and install Buildroot):

mkdir ~/output && cd ~/output
make O=$PWD -C /var/buildroot-2024.11.1 \
BR2_EXTERNAL=~/br2-external-tree raspberrypi5_defconfig

This assumes Buildroot version 2024.11.1 is installed in the /var directory.

Linux Kernel configuration

Device Tree

WLAN interface for the Raspberry Pi 5 is defined in two separate Device Tree Source (DTS) files included in the default configuration for Raspberry Pi 5 board in the Linux Kernel source. These files are:

If you're unfamiliar with DTS files, one of my previous posts provides a brief introduction.

The SDIO interface used by the onboard Wi-Fi is described in the following DTS entry:

sdio2: mmc@1100000 {
    compatible = "brcm,bcm2712-sdhci";
    reg = <0x10 0x01100000  0x0 0x260>,
          <0x10 0x01100400  0x0 0x200>;
    reg-names = "host", "cfg";
    interrupts = <GIC_SPI 274 IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&clk_emmc2>;
    sdhci-caps-mask = <0x0000C000 0x0>;
    sdhci-caps = <0x0 0x0>;
    supports-cqe;
    mmc-ddr-3_3v;
    status = "disabled";
};

This interface is later referenced and enabled in another section of the DTS, which also includes the WLAN device node:

&sdio2 {
    pinctrl-0 = <&sdio2_30_pins>;
    pinctrl-names = "default";
    bus-width = <4>;
    vmmc-supply = <&wl_on_reg>;
    sd-uhs-ddr50;
    non-removable;
    status = "okay";
    #address-cells = <1>;
    #size-cells = <0>;

    wifi: wifi@1 {
        reg = <1>;
        compatible = "brcm,bcm4329-fmac";
        local-mac-address = [00 00 00 00 00 00];
    };
};

Device drivers

To ensure the wireless module on the Raspberry Pi 5 functions correctly, the Linux Kernel must be properly configured. Specifically, the Kernel should include support for both the generic wireless stack and the Raspberry Pi 5’s Broadcom-based hardware.

The following options should be enabled in the Kernel configuration by running make linux-menuconfig inside output folder:

[*] Networking support --->
  [*] Wireless --->
    <M> cfg80211 - wireless configuration API
    [*] enable powersave by default
    [*] support CRDA
    [*] cfg80211 wireless extensions compatibility

Device Drivers --->
  [*] Network device support --->
    [*] Wireless LAN ---> 
       [*] Broadcom devices
       <M> Broadcom FullMAC WLAN driver
       [*] SDIO bus interface support for FullMAC driver

All other Kernel options were left at their default values.

Firmware Custom Package

Many wireless network interfaces require firmware to be loaded by the Kernel at runtime. This is the case for the CYW43455 used on the Raspberry Pi 5. However, this firmware is not available in any of Buildroot’s in-tree packages. To solve this, br2-external tree feature can be leveraged to create a custom package that fetches the firmware from its official repository and installs it in the appropriate location within the target root filesystem

Creating the Custom Package

First, create a folder to hold the files that describe your custom package (i.e. .mk and Config.infiles):

mkdir -p ~/br2-external-tree/package/brcmfmac-firmware

Create the Config.in file to define how this package appears in Buildroot's menuconfig and what option name it uses:

cat > ~/br2-external-tree/package/brcmfmac-firmware/Config.in << 'EOF' 
config BR2_PACKAGE_BRCMFMAC_FIRMWARE
  bool "BRCMFMAC Firmware"
  default n
  help
    Downloads and install CYW43455 firmware from Linux Kernel source
EOF

Next, define the .mk file to tell Buildroot where to fetch the firmware and how to install it under /lib/firmware/brcm:

cat > ~/br2-external-tree/package/brcmfmac-firmware/brcmfmac-firmware.mk << 'EOF' 
BRCMFMAC_FIRMWARE_VERSION := 20250311
BRCMFMAC_FIRMWARE_SOURCE := linux-firmware-$(BRCMFMAC_FIRMWARE_VERSION).tar.gz
BRCMFMAC_FIRMWARE_SITE := https://web.git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git/snapshot

define BRCMFMAC_FIRMWARE_INSTALL_TARGET_CMDS
  $(INSTALL) -D -m 0644 $(@D)/cypress/cyfmac43455-sdio.bin $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.bin

  $(INSTALL) -D -m 0644 $(@D)/cypress/cyfmac43455-sdio.clm_blob $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.clm_blob

  $(INSTALL) -D -m 0644 $(@D)/brcm/brcmfmac43455-sdio.raspberrypi,4-model-b.txt $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.txt

  $(INSTALL) -D -m 0644 $(@D)/cypress/cyfmac43455-sdio.bin $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.raspberrypi,5-model-b.bin

  $(INSTALL) -D -m 0644 $(@D)/cypress/cyfmac43455-sdio.clm_blob $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.raspberrypi,5-model-b.clm_blob

  $(INSTALL) -D -m 0644 $(@D)/brcm/brcmfmac43455-sdio.raspberrypi,4-model-b.txt $(TARGET_DIR)/lib/firmware/brcm/brcmfmac43455-sdio.raspberrypi,5-model-b.txt
endef

$(eval $(generic-package))
EOF

Registering the Package

Finally, add an entry in the top-level Config.in file of your br2-external tree so the package appears in the menuconfig:

cat > ~/br2-external-tree/Config.in << 'EOF' 
menu "Raspberry Pi 5 Customizations"
source "$BR2_EXTERNAL_DEV_TO_TREE_PATH/package/brcmfmac-firmware/Config.in"
endmenu
EOF

And enable the option just that had just been created:

cd ~/output
make menuconfig

The new option should be located in External options -> Raspberry Pi 5 Customizations.

WPA Supplicant and Wireless Interface Setup

Jumping into the user space, WPA Supplicant can be used to manage the wireless interface. This package in located under Target packages -> Networking applications after running make menuconfig from output folder. The following options should be enabled:

BR2_PACKAGE_WPA_SUPPLICANT=y
BR2_PACKAGE_WPA_SUPPLICANT_WEXT=y
BR2_PACKAGE_WPA_SUPPLICANT_CLI=y
BR2_PACKAGE_WPA_SUPPLICANT_PASSPHRASE=y

Additionally, enable the iw and wireless-regdb packages from the same section:

BR2_PACKAGE_IW=y
BR2_PACKAGE_WIRELESS_REGDB=y

Proceeding to the configuration of the wireless interface, it will be set up to obtain an IP address from a wireless access point using DHCP, with WPA Supplicant handling the connection. As before, br2-external tree will be used to store this configuration under the rootfs_overlay folder.

mkdir -p ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/network

cat > ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/network/interfaces << 'EOF'
auto lo
iface lo inet loopback

auto wlan0
iface wlan0 inet dhcp
   pre-up wpa_supplicant -B -Dnl80211,wext -i wlan0 -c /etc/wpa_supplicant.conf
   post-down killall -q wpa_supplicant
EOF

As seen above, WPA Supplicant is expecting a configuration file, which should be stored inside /etc folder. This file tells WPA Supplicant how to connect to your Wi-Fi network. Create it by running:

cat > ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/wpa_supplicant.conf << 'EOF'
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=BR

network={
ssid=<your_ssid>
psk=<your_passphrase>
}
EOF

❗ Make sure to edit this file passing the SSID and the password for the desired network.

Post-Boot Driver Initialization

During the Kernel configuration CYW43455 device drivers were configured to be compiled as modules. The reason for that is that they cannot be loaded before the root filesystem is mounted, as it is expected that the Kernel to load the firmware for the CYW43455 hardware, which is is stored in /lib/firmware/brcm. To ensure the drivers load properly at boot, an init script that loads the modules once the system is up could be created as follows:

mkdir -p ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/init.d

cat > ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/init.d/S35wlan_modules << 'EOF'
#!/bin/sh

install_wlan_modules() {
  modprobe brcmutil || return 1
  modprobe brcmfmac || return 1
  sleep 5
  return 0
}

uninstall_wlan_modules() {
  rmmod brcmfmac || return 1
  rmmod brcmutil || return 1
  return 0
}

case "$1" in
  start)
    printf "Installing wlan modules... "
    install_wlan_modules
    [ $? -eq 0 ] && echo "OK" || echo "FAIL"
    ;;
  stop)
    printf "Uninstalling wlan modules... "
    uninstall_wlan_modules
    [ $? -eq 0 ] && echo "OK" || echo "FAIL"
    ;;
  restart)
    printf "Uninstalling wlan modules... "
    uninstall_wlan_modules
    [ $? -eq 0 ] && echo "OK" || echo "FAIL"

    printf "Installing wlan modules... "
    install_wlan_modules
    [ $? -eq 0 ] && echo "OK" || echo "FAIL"
    ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
    exit 1
    ;;
esac

exit $?
EOF

Make sure to add execution permission for the script we just created:

chmod +x ~/br2-external-tree/board/raspberrypi5/rootfs_overlay/etc/init.d/S35wlan_modules

Configuring the Root Filesystem Overlay

All is there left to do is to configure the BR2_ROOTFS_OVERLAY so Buildroot knows where to find the settings that were just created. This option is located under System configuration after running make menuconfig inside output folder.

BR2_ROOTFS_OVERLAY="$(BR2_EXTERNAL_DEV_TO_TREE_PATH)/board/raspberrypi5/rootfs_overlay"

Once everything is saved, the compilation can be triggered by running make inside output folder.

Flashing the Image to an SD Card

After the compilation is complete without errors, the final binary file will be located in the output/images folder and will be named sdcard.img. This is the file that needs to be written to the SD card to boot the Raspberry Pi board, which can be done by the following (assuming it is enumerated as /dev/sda):

dd if=images/sdcard.img of=/dev/sda status=progress

Conclusion

📡 And that’s it! You’ve just enabled the Raspberry Pi 5's onboard Wi-Fi from scratch using Buildroot. From configuring kernel modules and creating a custom firmware package to using wpa_supplicant and automating initialization on boot, you now have control over the wireless interface for custom networking scenarios.

If you found this post helpful or ran into issues along the way, feel free to drop your questions, suggestions, or just share your thoughts in the comments section. I’d love to hear how you're using Raspberry Pi 5 in your own projects — or if there's something you’d like to see covered in a future post!

Enabling Ethernet support and OpenSSH on Raspberry Pi 5 with Buildroot

Paulo Fylippe Sell — Mon, 07 Apr 2025 11:15:17 +0000

In my last post, I discussed logging into a Raspberry Pi 5 image built with Buildroot over a serial connection. However, this method requires either the official debug probe or a more common serial adapter.

Another widely used alternative is leveraging the Raspberry Pi 5's Ethernet port to log into the system using SSH.

Device Tree configuration

The Ethernet interface for the Raspberry Pi 5 is defined in two different Device Tree Source (DTS) files included in the Linux Kernel source. These files are:

A DTS (Device Tree Source) file is a human-readable text file that describes hardware components and their configurations for systems using the Device Tree, such as Linux-based embedded systems. This file is compiled into a DTB (Device Tree Blob), which the operating system reads at boot time to understand the hardware layout without relying on hardcoded Kernel configurations.

The Ethernet interface is described in the following DTS entry:

rp1_eth: ethernet@100000 {
    reg = <0xc0 0x40100000  0x0 0x4000>;
    compatible = "cdns,macb";
    #address-cells = <1>;
    #size-cells = <0>;
    interrupts = <RP1_INT_ETH IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&macb_pclk &macb_hclk &rp1_clocks RP1_CLK_ETH_TSU>;
    clock-names = "pclk", "hclk", "tsu_clk";
    phy-mode = "rgmii-id";
    cdns,aw2w-max-pipe = /bits/ 8 <8>;
    cdns,ar2r-max-pipe = /bits/ 8 <8>;
    cdns,use-aw2b-fill;
    local-mac-address = [00 00 00 00 00 00];
    status = "disabled";
};

And it is referenced and enabled in the following DTS entry:

&rp1_eth {
    status = "okay";
    phy-handle = <&phy1>;
    phy-reset-gpios = <&rp1_gpio 32 GPIO_ACTIVE_LOW>;
    phy-reset-duration = <5>;

    phy1: ethernet-phy@1 {
        reg = <0x1>;
        brcm,powerdown-enable;
    };
};

Installing and Setting Up Buildroot

Assuming all required dependencies are already installed, Buildroot can be downloaded and extracted as follows:

mkdir ~/buildroot && cd ~/buildroot
wget https://buildroot.org/downloads/buildroot-2024.11.1.tar.gz 
tar zxf buildroot-2024.11.1.tar.gz --strip-components=1

Next, create an output directory where Buildroot will store all build artifacts, and configure it for the Raspberry Pi 5:

cd ~/buildroot 
mkdir output && cd output
make O=$PWD -C ../buildroot-2025.02 raspberrypi5_defconfig

Enabling Ethernet Support for Raspberry Pi 5

Raspberry Pi 5 features a Cadence Ethernet controller integrated into the RP1 chip and a Broadcom BCM54213 PHY connected to it. To support Ethernet networking, the following Kernel configuration options must be enabled:

CONFIG_NET_VENDOR_CADENCE
CONFIG_MACB
CONFIG_BROADCOM_PHY

These configuration can be enable from within Buildroot output folder, by simply running:

make linux-menuconfig

These options ensure that the necessary device drivers are compiled to support Ethernet functionality. The rest of the Kernel configuration, including network stack configuration, remains as per the default.

Enabling OpenSSH in Buildroot

To enable the OpenSSH server and client in your image, open the Buildroot menu configuration tool:

make menuconfig

Then, navigate to Target packages -> Networking applications. Once inside, scroll down to find and enable OpenSSH:

We also will need ifupdown scripts enabled to be able to bring our network up when needed. While still in Target packages -> Networking applications, make sure the following option is enable (should be default for Raspberry Pi 5):

BR2_PACKAGE_IFUPDOWN_SCRIPTS=y

Customizing the Root Filesystem

In order to store OpenSSH custom configuration file, we can take advantage of a Buildroot feature called RootFS Overlay. We will also use this feature to configure our network interface.

Before enabling the feature, it is necessary to create a folder that will store the RootFS overlay. The folder must have the following tree:

+-- rootfs_overlay
|    +-- etc/
|        +-- ssh/
|            +-- sshd_config
|        +-- network/
|            +-- interfaces

To create such a folder-tree, one can run:

mkdir -p ~/rootfs_overlay/etc/ssh ~/rootfs_overlay/etc/network

sshd_config must contain the configuration for the ssh server we are building. In this case, we could only enable root login over ssh, by running the following:

echo "PermitRootLogin yes" > ~/rootfs_overlay/etc/ssh/sshd_config

Note that enabling root login over ssh is not recommended in a real-life application due to cyber security reasons.

For the network configuration, interfaces file should be filled using the following command:

cat > ~/rootfs_overlay/etc/network/interfaces << EOF
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
  address 192.168.0.199
  netmask 255.255.255.0
  gateway 192.168.0.1
  pre-up /etc/network/nfs_check
  wait-delay 15
  hostname $(hostname)
EOF

Back on output folder, on Buildroot menu one must enable the following option, passing the path of the rootfs_overlay folder that had just been created:

BR2_ROOTFS_OVERLAY="~/rootfs_overlay"

By setting this option, Buildroot will copy each file or folder from the configured path directly over the target file system after it has been built. Hidden directories of version control systems, like .git, .svn, .hg, etc., files called .empty and files ending in ~ are excluded from the copy.

We should also set the root password so we can later login over ssh. Using the arrow keys and Enter key to navigate through the Buildroot menu, the root password can be set by on the following option:

-> System configuration
| -> Enable root login with password (BR2_TARGET_ENABLE_ROOT_LOGIN [=y])

Once everything is set up, the compilation can be triggered by running:

make

After the compilation is finished without errors, all is left to do is to write the image into the SD card (assuming it is enumerated as /dev/sda), by running:

dd if=images/sdcard.img of=/dev/sda status=progress

Connecting to the Board Over SSH

After finishing flashing and powering up the board, it is necessary to connect an Ethernet cable between the board and the host computer. It is also necessary to set a static IP on the host's network interface so we can communicate with the board:

ifconfig interface_name down
ifconfig interface_name 192.168.0.190 netmask 255.255.255.0
ifconfig interface_name up

Finally, we must install OpenSSH client on our host computer, and run the ssh command to login into root user using the IP address we configured previously on interfaces file (assuming Debian/Ubuntu environment):

apt-get install openssh-client
ssh root@192.168.0.199

If everything went fine, you should now be logged in the board and be able to use it over SSH protocol.

Conclusion

And that’s it for this post! With everything set up, your Raspberry Pi 5 Buildroot image is ready to roll over SSH. Whether you're building a cool project or just diving deeper into embedded Linux, I hope this guide helped you somehow.

💬 If you found this helpful, drop a like or leave a comment — I'd love to hear what you're working on!

Custom Linux Image for Raspberry Pi 5: A Guide with Buildroot

Paulo Fylippe Sell — Tue, 01 Apr 2025 20:49:27 +0000

Earlier this year, I got my hands on a Raspberry Pi 5 with the goal of expanding my knowledge of embedded systems, device drivers, the Linux Kernel, and related technologies. My objective is to explore several features of the Raspberry Pi 5, systematically enabling and configuring its functionalities until I achieve a fully functional image capable of managing all the board's main peripherals. Since I was already working on a project that uses Buildroot to generate a Linux system from scratch, I decided to integrate it into my learning process.

What is Buildroot?

According to its own documentation, Buildroot is a powerful tool that simplifies and automates the process of creating embedded Linux images, including the bootloader, Linux kernel, and root filesystem. It also generates a cross-compilation toolchain that can be used independently of Buildroot. Supporting a wide range of processors, Buildroot allows users to customize a Linux image from scratch according to the own needs. Fortunately, it includes several default configurations for various boards — including the Raspberry Pi 5 — making the setup process much more accessible.

By the time I started working on this project, the default configuration for Raspberry Pi 5 was already available in Buildroot 2024.11.1, which is the version I chose to use. Before diving into building the Linux image, the host computer must meet several mandatory and optional requirements. To install all the necessary packages in a Debian/Ubuntu environment (sudo may be required), you can run the following command:

apt-get update && apt-get upgrade -y && apt-get install -y which \
sed binutils build-essential diffutils gcc g++ bash patch gzip   \
bzip2 perl tar cpio unzip rsync file bc findutils wget python3   \
libncurses5-dev libncursesw5-dev libncurses5 libncursesw5 git    \
curl cvs mercurial openssh-client subversion

Once all the packages are installed, we’re ready to start building our image. To download Buildroot 2024.11.1, run the following command:

mkdir ~/buildroot && cd ~/buildroot
wget https://buildroot.org/downloads/buildroot-2024.11.1.tar.gz 
tar zxf buildroot-2024.11.1.tar.gz --strip-components=1

The commands above will download and extract the specified Buildroot version. If you need a different version, you can find all available releases here. Buildroot follows a quarterly release cycle, with monthly bug-fix updates to ensure stability and improvements.

Configuring the build

After downloading Buildroot, the next step is to configure our build using the default Raspberry Pi 5 configuration. It's best practice to build the image outside the Buildroot source folder. To do this, run the following commands:

cd ~/buildroot 
mkdir output && cd output
make O=$PWD -C ../buildroot-2025.02 raspberrypi5_defconfig

If you see an output similar to the image below, the configuration was successful.

Before starting the build, we can make some customization, such as setting a root password for the system. To do this, run the following command:

make menuconfig

This will open a curses-based configurator, similar to the one used in the Linux kernel project.

Using the arrow keys and Enter key to navigate through the menu, you can set the root password by going to the following option:

-> System configuration
| -> Enable root login with password (BR2_TARGET_ENABLE_ROOT_LOGIN [=y])

After saving your changes and exiting the configuration menu, you can start the build process by simply running the following command:

make

This will trigger the compilation of the root filesystem and the Linux kernel for the Raspberry Pi 5. The process can take one to two hours, as it involves building everything from scratch, including host dependencies and the toolchain.

After the compilation is complete without errors, the final binary file will be located in the images folder and will be named sdcard.img. This is the file that needs to be written to the SD card to boot the Raspberry Pi board. To write the image to the SD card (assuming it is enumerated as /dev/sda), run the following command:

dd if=images/sdcard.img of=/dev/sda status=progress

Once the SD card has finished flashing, the final step is to power up the board. You should be able to log in to the system using the password you set earlier. A serial connection can be used to access the system and log in. The serial session will also be helpful to troubleshoot any issue you face while booting the system.

Conclusion

🔥 And that's it! You’ve successfully built a custom Linux image for your Raspberry Pi 5 using Buildroot, configured it, and flashed it onto an SD card. This process not only gives you a deeper understanding of embedded systems, but also provides you with a powerful, customizable environment tailored to your needs.

If you have any questions or run into issues, feel free to leave a comment below! I'm happy to help with any doubts you may have. Additionally, if you've made any interesting customizations or run into unique challenges, I’d love to hear about them in the comments. Let’s keep the discussion going!

For more detailed information and advanced configurations, you can explore the official Buildroot manual.

Forem: Paulo Fylippe Sell

Monitoring and Controlling CPU Temperature on Linux Systems Using Sysfs

Enabling the thermal sensor

Enabling the active cooler

Buildroot configuration

Monitoring the temperature via sysfs

Conclusion

Enabling Raspberry Pi 5 Onboard Wi-Fi using Buildroot External Tree

Buildroot External Tree

Recommended directory structure

Build Configuration for Raspberry Pi 5

Linux Kernel configuration

Device Tree

Device drivers

Firmware Custom Package

Creating the Custom Package

Registering the Package

WPA Supplicant and Wireless Interface Setup

Post-Boot Driver Initialization

Configuring the Root Filesystem Overlay

Flashing the Image to an SD Card

Conclusion

Enabling Ethernet support and OpenSSH on Raspberry Pi 5 with Buildroot

Device Tree configuration

Installing and Setting Up Buildroot

Enabling Ethernet Support for Raspberry Pi 5

Enabling OpenSSH in Buildroot

Customizing the Root Filesystem

Connecting to the Board Over SSH

Conclusion

Custom Linux Image for Raspberry Pi 5: A Guide with Buildroot

What is Buildroot?

Configuring the build

Conclusion

Monitoring the temperature via `sysfs`