Supported Devices
Odroid XU4
 | CPU Information model name : ARMv7 Processor rev 3 (v7l) BogoMIPS : 60.00 Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt CPU implementer : 0x41 CPU architecture: 7 CPU variant : 0x0 CPU part : 0xc07 CPU revision : 3 : Hardware : Samsung Exynos (Flattened Device Tree) Revision : 0000 Serial : 0000000000000000 |
- About this device
- Introduction
- Needed stuff
- Preparation
- Installation
- Configuration
- Additional information
- Links
About this device
New generation of computing device based on a Samsung Exynos5422.
This development board was generously donated by Reverso Labs in 2016 to support the development of CRUX-ARM for this device.
After all these years, we continue to use and maintain it actively, highlighting its lasting value and reliability.
Introduction
To install CRUX-ARM on an Odroid-XU4, the first step is to prepare a microSD card with the appropriate partitions, install a compatible bootloader, and deploy the CRUX-ARM root filesystem.
This process involves creating the necessary partition layout tailored to the device, setting up the bootloader files (such as the zImage specific to Odroid-XU4), and extracting the CRUX-ARM system files onto the designated partition.
The following sections will provide a detailed, step-by-step guide covering each of these tasks to ensure a smooth and reliable installation tailored for ARM architecture. This approach leverages CRUX-ARM’s simplicity and flexibility, allowing users to build a lightweight and customizable Linux environment optimized for ARM-powered devices like the Odroid-XU4.
Important:
The ODROID-XU4 features a boot configuration slide-switch (located next to the eMMC and microSD slots) that selects the boot media. To boot from the microSD card, you must set this switch to the "SD" position before powering on the device. The board does not automatically fall back to the SD card if no eMMC is present, so this step is essential for a successful boot from microSD
Needed stuff
- U-boot bootloader
- Extlinux config file
- Kernel
- DTB file
- Kernel modules
- Kernel headers (not strictly necessary)
- Official optimized release for the Odroid-XU4
Preparation
Before beginning the installation process, you will need access to a computer (running Linux is recommended) and a microSD card with sufficient capacity for the CRUX-ARM root filesystem. The microSD card will be used to store the bootloader, the necessary partitions, and the CRUX-ARM system itself. Ensure you have a card reader and the appropriate permissions to write to the device.
Installation
1. Flashing the Bootloader
The first step is to write the bootloader (u-boot) to the microSD card. This is essential for the Odroid-XU4 to initialize and start the operating system. Use the following command, replacing ${card} with the device path of your microSD card (for example, /dev/mmcblkX).
Notice that we are using here our U-boot build which is bigger in size than the original one so we need to use the script sd_fusing.1M.sh:
git clone https://github.com/hardkernel/u-boot.git -b odroidxu3-v2012.07
cd u-boot/sd_fuse/hardkernel_1mb_uboot/
cp u-boot-dtb.bin .
./sd_fusing.1M.sh /dev/${card}
Warning: Be very careful to select the correct device path for your microSD card, as using the wrong device could overwrite important data.
U-BOOT doesn't implement SPL. So, BL1, BL2, and TrustZone binaries are needed to boot up.
2. Partitioning the microSD Card
After installing the bootloader, you need to create two partitions on the microSD card. First one of type W95 FAT32 and the second one of Linux type. The first partition will be used for boot and the second partition will contain the CRUX-ARM root filesystem.
You can use tools like fdisk or parted to create the partition. For example, using fdisk:
fdisk ${card}
Create a new primary partition (type: W95 FAT32, usually type 0b). This partition must start over 4096 sector. We need to reserve 2M for U-boot
Create a new primary partition (type: Linux, usually type 83).
Write the changes and exit.
Then, format the partitions as vfat and ext4 (replace ${card}X with your partition name):
mkfs.vfat ${card}1
mkfs.ext4 ${card}2
Once the partition is ready, you can proceed to deploy the latest version of CRUX-ARM onto it and configure it.
3. Verify CRUX-ARM release checksum
Before proceeding, it is crucial to verify the integrity of the downloaded CRUX-ARM root filesystem archive. This is done by calculating its SHA-256 checksum and comparing it to the official checksum provided by the source. This step ensures that the file has not been corrupted or tampered with during download:
sha256sum crux-3.8-armhf-odroidxu4-rootfs.tar.xz
If the computed checksum matches the official value, you can safely continue with the installation.
4. Extracting CRUX-ARM rootfs into the created partition
Next, mount the previously created partition to a temporary mount point (e.g., /mnt) and extract the CRUX-ARM root filesystem archive onto it. This will deploy all necessary system files onto the microSD card:
mount ${card}2 /mnt
tar pxvf crux-3.8-armhf-odroidxu4-rootfs.tar.xz -C /mnt
Ensure the extraction completes without errors before proceeding.
5. Prepare boot needed files
To enable the Odroid-XU4 to boot CRUX-ARM, certain boot files must be placed in the appropriate directories on the microSD card:
- Mount the first partition (boot) into the system.
- Copy the Linux kernel image (zImage) and the device tree blob (exynos5422-odroidxu4.dtb) into /mnt/boot/extlinux.
Commands example:
mount /dev/{card}1 /mnt/boot
mkdir /mnt/boot/extlinux
cp zImage /mnt/boot/extlinux/
cp exynos5422-odroidxu4.dtb /mnt/boot/extlinux/
cp extlinux.conf /mnt/boot/extlinux/
This setup allows the bootloader to find the kernel and configuration needed to start the system.
Provided extlinux.conf file allows booting from the second partition of the SD card:
label CRUX-ARM_Odroid-XU4-SDcard kernel zImage fdt exynos5422-odroidxu4.dtb append console=tty1 console=ttySAC2,115200 earlyprintk root=/dev/mmcblk2p2 rootwait
It's possible to change it to boot from USB drive or eMMC.
6. Finally uncompress kernel modules and headers
The last step is to extract the kernel modules and headers into the root filesystem. These components are essential for hardware support and compiling additional software:
tar pxvf modules-6.14.8.tar.xz -C /mnt tar pxvf headers-6.14.8.tar.xz -C /mnt umount /mnt/boot umount /mnt
After this, the microSD card will be fully prepared with the CRUX-ARM system, ready to boot on the Odroid-XU4.
Configuration
After deploying the CRUX-ARM root filesystem, it is important to configure several key system files to ensure proper operation and customization of your installation. The following files should be reviewed and edited according to your needs:
- /etc/pkgmk.conf
- Configure build options and package directories for pkgmk, the package building tool.
- /etc/prt-get.conf
- Set up the package management frontend, specifying the ports tree locations and other preferences for prt-get.
- /etc/inittab
- Define system runlevels and configure console access, including serial console settings if needed (e.g., enabling serial login on ttyS0).
- /etc/fstab
- List all filesystems and mount points to be mounted at boot. Make sure your root partition and any additional filesystems are correctly specified.
- /etc/rc.conf
- Set system-wide settings such as hostname, keyboard layout, timezone, and enabled services.
- /etc/network.d/net or /etc/rc.d/net
- Configure your network interface settings to ensure connectivity at boot.
Review and adjust these files to match your hardware, network environment, and personal preferences. Proper configuration at this stage will ensure a smooth and stable experience with CRUX-ARM on your Odroid-XU4.
Note: For detailed explanations and examples of these configuration files, please refer to the official CRUX Handbook. The handbook provides comprehensive guidance on system configuration and package management, which can be especially helpful for new users.
Additional information
Customization
Serial Console
To obtain serial access:
- Uncomment and change the line in /etc/inittab:
s1:2:respawn:/sbin/agetty 115200 ttySAC2 vt100
- In the client side (using minicom here): it's needed to disable hardware flow control to get input events working.
Installing linux-firmware for Full Hardware Support
To ensure that all hardware components of the Odroid XU4 function correctly under CRUX-ARM, it is essential to install the appropriate firmware files. Many devices on the board, such as Wi-Fi, Bluetooth, and certain multimedia interfaces, depend on proprietary firmware that is not included in the kernel by default.
CRUX provides a dedicated port, linux-firmware, which contains the necessary firmware binaries for a wide range of hardware. Installing this package is required to guarantee that all features of the Odroid XU4 are supported.
You can install the firmware package and its dependencies using the following command:
prt-get depinst linux-firmware Note: Without installing linux-firmware, certain devices on the Odroid XU4 may not function properly or may not be detected at all.
This command will automatically resolve and install any required dependencies along with the linux-firmware package, ensuring that your Odroid XU4 hardware operates as intended
After installation, it is recommended to reboot the system to load the newly installed firmware.
CPU Governor Configuration for Odroid-XU4
The Odroid-XU4 features a Samsung Exynos 5422 SoC with a big.LITTLE architecture: four high-performance Cortex-A15 cores (up to 2.0 GHz) and four energy-efficient Cortex-A7 cores (up to 1.4 GHz). Each cluster can be configured independently for CPU frequency scaling and governor settings.
To view available governors and frequencies for each cluster:
# Efficiency cluster (Cores 0-3) cat /sys/devices/system/cpu/cpufreq/policy0/scaling_available_governors cat /sys/devices/system/cpu/cpufreq/policy0/scaling_available_frequencies # Performance cluster (Cores 4-7) cat /sys/devices/system/cpu/cpufreq/policy4/scaling_available_governors cat /sys/devices/system/cpu/cpufreq/policy4/scaling_available_frequencies
To set the governor and frequency limits for each cluster:
# Efficiency cluster (Cores 0-3) echo "ondemand" > /sys/devices/system/cpu/cpufreq/policy0/scaling_governor echo "200000" > /sys/devices/system/cpu/cpufreq/policy0/scaling_min_freq echo "1000000" > /sys/devices/system/cpu/cpufreq/policy0/scaling_max_freq # Performance cluster (Cores 4-7) echo "performance" > /sys/devices/system/cpu/cpufreq/policy4/scaling_governor echo "600000" > /sys/devices/system/cpu/cpufreq/policy4/scaling_min_freq echo "1600000" > /sys/devices
To setup a "ondemand" governor for all CPU cores:
for core in {0..7}; do echo 'ondemand' | sudo tee /sys/devices/system/cpu/cpufreq/policy${core}/scaling_governor; done
CPU Temperature Monitoring for Odroid-XU4
The Odroid-XU4 features multiple thermal sensors, primarily for each of the four Cortex-A15 "big" cores and the GPU block. These sensors are accessible via the sysfs interface. You can check the temperature readings by inspecting the following files:
cat /sys/class/thermal/thermal_zone0/temp cat /sys/class/thermal/thermal_zone1/temp cat /sys/class/thermal/thermal_zone2/temp cat /sys/class/thermal/thermal_zone3/temp cat /sys/class/thermal/thermal_zone4/temp
Each file reports the temperature in millidegrees Celsius (e.g., "45000" means 45.0°C). To display the temperature in a human-readable format, you can use:
awk '{printf "%3.1f°C\n", $1/1000}' /sys/class/thermal/thermal_zone0/temp
Repeat this command for each thermal zone as needed. Note that the values may differ slightly between sensors, as they monitor different parts of the SoC
Fan Control for Odroid-XU4
The Odroid-XU4 features an automatic cooling fan managed by the Linux kernel’s thermal management driver. By default, the fan operates at three speed levels based on SoC temperature thresholds:
| Trip Point | Temperature | Fan Speed (PWM) |
| 0 | 60°C | 120 |
| 1 | 70°C | 180 |
| 2 | 80°C | 240 |
Below 60°C, the fan remains off.
The fan speed can be adjusted via an 8-bit PWM value (range: 0–255).
Customizing Temperature Thresholds
You can modify the temperature trip points by writing new values (in millidegrees Celsius) to the sysfs nodes. For example, to set the first trip point to 30°C:
echo 30000 | sudo tee /sys/devices/virtual/thermal/thermal_zone{0,1,2,3}/trip_point_0_temp
Customizing Fan Speeds
To change the fan speed values associated with each trip point:
echo "0 204 220 240" | sudo tee /sys/devices/platform/pwm-fan/hwmon/hwmon0/fan_speed
Manual Fan Control
To disable automatic control and set the fan speed manually:
echo 0 | sudo tee /sys/devices/platform/pwm-fan/hwmon/hwmon0/automatic echo 255 | sudo tee /sys/devices/platform/pwm-fan/hwmon/hwmon0/pwm1 # 100% speed
To make your custom settings persistent, add the relevant commands to /etc/rc.local
Tweaks and Tricks for Odroid-XU4
Downclocking the GPU for Power Savings
If you use the Odroid-XU4 as a headless server, you can reduce power consumption by downclocking the GPU, which otherwise runs at its maximum clock rate even when not in use. This can reduce overall power usage by up to 20% in some scenarios
Reducing Power Consumption by Disabling Unused CPU Cores
If you want to minimize energy usage, you can disable unused CPU cores:
echo 0 > /sys/devices/system/cpu/cpuX/online
Replace X with the core number you wish to disable. This is useful for 24/7 headless operation where maximum performance is not required
Links
https://wiki.odroid.com/odroid-xu4/odroid-xu4
https://wiki.odroid.com/odroid-xu4/software/partition_table
https://wiki.odroid.com/odroid-xu4/software/building_u-boot_mainline
https://source.denx.de/u-boot/u-boot/-/blob/v2025.04/doc/README.odroid
https://wiki.odroid.com/odroid-xu4/software/building_kernel
Reference on how we build U-boot/Kernel