Getting Started for Embedded Linux Engineers

This hub is the entry point for engineers working on embedded Linux platforms at Amarula Solutions. Whether you are bringing up a new board, setting up a build system, or contributing to the upstream kernel, the content here will guide you through the full development lifecycle — from your first cross-compilation toolchain to production-grade CI/CD pipelines.

Who Is This For?

New to embedded Linux:

You’ll find step-by-step host setup, toolchain installation, and board bring-up guides that take you from zero to a booting system.

Experienced BSP developer:

Deep-dive references for U-Boot, kernel configuration, OP-TEE secure boot, and upstream contribution workflows.

DevOps / CI engineer:

Jenkins pipeline libraries, Gerrit integration, build throttling, and containerized build infrastructure.

Engineering manager:

Overviews of our build-system strategy (Yocto vs Buildroot), security integration, and open-source compliance practices.

Curious who wrote this?:

Every guide on this wiki is written by Amarula Solutions engineers actively contributing upstream. Browse our open source team directory to see the people behind the patches.

The Embedded Linux Learning Path

Embedded Linux development follows a natural progression. The sections below are ordered to match the workflow you’ll encounter in a real project.

1. Understand the System Architecture

Before writing code, understand what you’re building:

  • Embedded Linux stack overview — boot ROM → SPL → U-Boot → Linux kernel → root filesystem → user-space applications.

  • Cross-compilation model — why you can’t compile on the target, and how the host/target split works in practice.

  • Upstream-first philosophy — why Amarula mainlines everything, and how that benefits both your project and the community.

See the About page for context on how we work and the open source contributions that back our expertise.

2. Set Up Your Development Host

Your host machine is your primary development tool. Get it right first.

  • Essential host packages — compilers, build tools, libraries, and debugging utilities for Ubuntu and Debian-based systems.

  • Cross-compilation toolchains — Linaro GCC for ARM, AArch64, and RISC-V targets, including installation and PATH setup.

  • Board communication tools — serial console (minicom), TFTP server, USB boot tools (rkdeveloptool, sunxi-fel), and fastboot/adb for Android.

  • Git bisect for kernel debugging — systematically find regressions in the Linux kernel with bisection.

Complete host setup guide →

Git bisect debugging →

3. Master the Bootloader: U-Boot

U-Boot is the gatekeeper before the kernel starts. Understanding it deeply is essential for board bring-up and production boot configuration.

  • Building U-Boot from mainline — per-platform build instructions for Allwinner, Rockchip, NXP i.MX, and RISC-V.

  • Boot methods — SD card, eMMC, USB (FEL mode for Allwinner, rkdeveloptool for Rockchip), and network (TFTP/NFS).

  • Falcon mode — skip U-Boot’s full initialization for sub-second boot times.

  • Verified boot — chain-of-trust from SPL through U-Boot to kernel using HABv4 (NXP i.MX) and other secure boot mechanisms.

  • Redundant boot — watchdog-triggered fallback images for production reliability.

  • U-Boot sandbox — test and debug U-Boot on your host without hardware.

See U-Boot section → for all bootloader topics.

4. Build and Configure the Linux Kernel

The Linux kernel is where most customisation happens. You’ll need to configure, build, and debug it for your target SoC.

  • Kernel source and branches — working with linux-next, stable trees, and vendor trees.

  • Device Tree configuration — enabling and configuring peripherals (I2C, SPI, display, camera, networking) through device trees.

  • Driver development and debugging — DRM display pipelines, MIPI DSI bridges, camera sensors (CSI), and USB Type-C/DisplayPort alt-mode.

  • Performance and boot-time optimization — profiling, tracing, and reducing kernel boot time.

Each BSP page includes kernel build instructions specific to that platform. For kernel-space development articles, browse the news section and articles.

5. Create the Root Filesystem

The root filesystem is everything userspace: init, shells, libraries, and applications.

  • From-scratch rootfs — directory structure, BusyBox, device nodes, init scripts.

  • Filesystem choices — ext4, squashfs, UBIFS — when to use each.

  • Partition layout — single-partition, dual-partition (A/B updates), and Falcon-mode layouts.

  • Storage media — SD card, eMMC, and raw NAND flash provisioning.

SD card and partition setup → (see SD Setup section)

6. Choose an Embedded Linux Build System

Manual builds give understanding; build systems give reproducibility and scale.

Yocto Project — for production-grade, customizable distributions:
Buildroot — for lightweight, single-purpose images:

Build systems hub → for the complete index.

7. Integrate Security

Security is not a bolt-on — it must be designed in from the start.

  • Secure boot chain — HABv4 on i.MX6/i.MX8M, OP-TEE trusted applications.

  • Filesystem encryption — TPM-backed LUKS, dm-verity for integrity.

  • A/B firmware updates — STM32MP A/B update with U-Boot and Mender.

  • Vulnerability scanning — Mend SCA (now Mend) in CI, SonarQube for code quality.

Security hub → | OP-TEE guides →

8. Automate with CI/CD

Amarula runs a Jenkins-based CI infrastructure integrated with Gerrit for code review. All BSP work flows through this pipeline.

CI/CD hub → | Shared libraries →

9. Contribute Upstream

Every project at Amarula follows an upstream-first approach. Contributions go to the mainline projects, not internal forks.

  • Linux kernel — git format-patch, checkpatch.pl, and b4 tool for mailing-list-based submission.

  • U-Boot — patches to the U-Boot mailing list (u-boot@lists.denx.de).

  • Buildroot — patches to the Buildroot mailing list and Patchwork.

  • Yocto / OpenEmbedded — layers submitted to the Yocto Project mailing list.

Amarula engineers serve as maintainers and regular contributors to all of these projects. See Open Source Contributions for our track record, and Open Source Activities for our maintainer roles.

Monthly contribution reports → for the latest activity.

Quick-Start Per Domain

Pick the path that matches what you’re working on right now.

Domain

What You’ll Learn

Start Here

Board Bring-Up

U-Boot build, kernel config, device tree, boot media setup

Board Support Packages

Yocto Development

Layer creation, image recipes, secure boot, CI integration

Embedded Linux Build Systems

Buildroot

Minimal images, Flutter apps, sstate caching

Embedded Linux Build Systems

Kernel / Drivers

DRM, MIPI DSI, CSI camera, device trees

News

Android AOSP

Board bring-up, CI pipelines, app signing, emulator testing

Android application

CI/CD Pipelines

Jenkins job DSL, Gerrit triggers, shared libraries

CI/CD & Test Automation

Security

Secure boot, OP-TEE, HABv4, dm-verity, vulnerability scanning

Embedded Security

Hardware Design

Schematic, PCB, FPGA, mechanical CAD, pre-compliance testing

Hardware Development

IoT & RTOS

Zephyr on ESP32 and TI CC3220, ESP32 camera projects

IoT Firmware & RTOS Development

AI / ML Tools

ReviewAI Gerrit plugin, Jelliphy framework

Amarula Products & Tools

Supported Hardware Platforms

Amarula maintains mainline Linux and U-Boot support across multiple SoC families:

Vendor

SoC Families

Featured Boards

Guide

Allwinner

A13, A20, A33, A64, H3, H5, H6

Olimex, Orange Pi, Pine64, Banana Pi

Allwinner

Rockchip

RK3288, RK3399, RK3399Pro, PX30

Vyasa, Rock Pi 4/N10, NanoPi M4, Tinker Board

Rockchip

NXP i.MX

i.MX6Q/DL, i.MX8M

Engicam i.CoreM6, i.CoreMX8M Mini

I.MX

RISC-V

SiFive FU540

HiFive Unleashed, QEMU

RISC-V

Amarula Custom

Vyasa (RK3288), Giotto

Custom engineering platforms

Amarula Reference Boards

Tools & Products

We maintain several open-source tools developed in-house:

Full products overview →

Training and Consulting

Amarula Solutions offers professional training, hands-on workshops, and engineering consulting across all embedded Linux domains:

  • Past workshops — Linux, Yocto, and mainline kernel workshops delivered at client sites and conferences like Embedded World.

  • Custom on-site training — tailored curriculum for your team’s stack and hardware.

  • Consulting services — board bring-up, BSP maintenance, mainline upstreaming, Yocto layer development, and CI infrastructure.

Contact us to discuss your project needs.