Sitemap
Open in app

Sign in

Medium Logo
Write
Search

Sign in

Sadikthanos

Sadikthanos

Embedded Linux Build Systems(Buildroot vs Yocto vs Debian)

Sadikthanos
14 min readOct 22, 2026

--

Press enter or click to view image in full size

A Comprehensive Comparison: Buildroot vs Yocto vs Debian on Texas Instruments SOC’s

Overview -The Challenge

Enabling complex silicon devices such as systems-on-a-chip (SoC) with operating firmware and application software can be a challenge for equipment manufacturers who often are more comfortable with hardware than software issues. The explosion of embedded Linux adoption has been driven by two primary factors: cost (44.6 percent) and availability of source code (33.1 percent), according to embedded developer surveys.

Before any applications can run on new silicon like TI’s Sitara processors, developers must assemble a complete software stack: operating system kernel, base filesystem, bootloader, compiler toolchain, device drivers, and application packages. Each component must be gathered, configured, and integrated into a coherent Linux distribution specific to the hardware platform.

The choice of build system fundamentally impacts:

  • Development velocity-Time from concept to working prototype
  • Customization capability -Ability to tailor the system to specific requirements
  • Maintenance burden -Effort required for updates, security patches, and long-term support
  • Team productivity-Learning curve and development efficiency
  • Product lifecycle-Scalability across product families and hardware variants

This article examines three distinct approaches to building embedded Linux systems for TI Sitara GP platforms: Buildroot (simplicity-focused), Yocto Project (enterprise-grade flexibility), and Debian/Armbian (desktop-class ecosystem).

Build System Fundamentals

What is a Build System?

An embedded Linux build system is a framework that automates the process of creating a complete, bootable Linux distribution for embedded hardware. It handles:

  • Cross-compilation toolchain generation for AArch64 (64-bit ARM) and Arm (32-bit) processors
  • Kernel configuration and building for specific SoCs
  • Root filesystem construction with selected packages
  • Bootloader configuration (U-Boot, TF-A,OP-TEE)
  • Dependency resolution between software components
  • Package management (build-time and optionally runtime)

Three Philosophies

The three build systems in this comparison represent fundamentally different philosophies:

Buildroot takes a monolithic, source-based approach: everything is compiled from source with minimal runtime overhead. Think of it as building a custom car from scratch -you control every component, but changes require rebuilding.

Yocto Project uses a layered, recipe-based architecture: metadata and recipes describe how to build components, with sophisticated dependency tracking. It’s like an automotive manufacturing platform-highly configurable, supports product families, requires upfront tooling investment.

Debian/Armbian follows a binary package distribution model: pre-compiled packages are installed from repositories. This is like buying a production car and adding accessories-quick to deploy, less customization at the foundation level, larger footprint.

To get started on these distros for a single platform like Texas Instruments AM62X please refer the following sources-:
Buildroot-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03_Buildroot/exports/docs/devices/AM62X/buildroot/index.html
Yocto-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03/exports/docs/devices/AM62X/index.html
Armbian/Debian-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03_Debian/exports/docs/devices/AM62X/debian/index.html

Buildroot

1. What is Buildroot?

Buildroot is a lightweight, open-source build system designed to generate complete embedded Linux systems quickly and efficiently. Initiated in 2001, Buildroot automates the creation of cross-compilation toolchains, Linux kernels, root filesystems, and bootloaders through a simple, unified configuration interface.

Buildroot’s philosophy centers on simplicity and reproducibility. Rather than managing runtime packages, Buildroot compiles everything from source at build time, creating a tightly integrated system optimized for the target hardware. This approach minimizes runtime overhead and creates highly deterministic builds.

The build process uses a Kconfig-based menuconfig interface (familiar to Linux kernel developers) where developers select target architecture, packages, filesystem options, and bootloader settings. Buildroot then downloads sources, applies patches, cross-compiles components, and assembles the final images.

Figure 1: Buildroot-based Linux Software for TI Devices

┌──────────────────────────────────────────────────────────────┐
│                     ① Applications                           │
│  ┌─────────────────────┐  ┌──────────────────────────────┐   │
│  │   GUI Applications  │  │     Custom Applications      │   │
│  ├─────────────────────┤  ├──────────────────────────────┤   │
│  │ Trusted Applications│  │   Middleware and Libraries   │   │
│  └─────────────────────┘  └──────────────────────────────┘   │
└───────────────────────────┬──────────────────────────────────┘
                            │
┌───────────────────────────▼──────────────────────────────────┐
│                  ② Buildroot Build System                    │
│  ┌───────────────────────┐  ┌─────────────────────────────┐  │
│  │       Buildroot       │  │     Buildroot External-TI   │  │
│  └───────────────────────┘  └─────────────────────────────┘  │
└───────────────────────────▲──────────────────────────────────┘
                            │
┌───────────────────────────┴────────────────────────────────── ┐
│                    ③ TI BSP Components                       
│  ┌──────────────────────────────────────────────────────────┐ │
│  │            Firmware and Security Components              │ │
│  │  ┌──────┐  ┌────────┐  ┌──────────────────┐  ┌───────┐   │ │
│  │  │ TF-A │  │ OP-TEE │  │  TI Linux Firmware│ │U-Boot │   │ │
│  │  └──────┘  └────────┘  └──────────────────┘  └───────┘   │ │
│  ├──────────────────────────────────────────────────────────┤ │
│  │               Linux Kernel Components                    │ │
│  │  ┌──────────────────┐  ┌───────────────┐  ┌───────────┐  │ │
│  │  │  TI Linux Kernel │  │ TI Kernel Drvs│  │ Device Tree│ │ │
│  │  └──────────────────┘  └───────────────┘  └───────────┘  │ │
│  └──────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────── ┘
                            │
                            ▼
┌──────────────────────────────────────────────────────────────┐
│                       Build Artifacts                        │
│  ┌────────────────┐  ┌──────────────────┐  ┌──────────────┐  │
│  │  SD Card Image │  │  Boot Artifacts  │  │Root Filesystem│ │
│  └────────────────┘  └──────────────────┘  └──────────────┘  │
└──────────────────────────────────────────────────────────────┘

2. What Can Be Built with Buildroot?

Buildroot can create complete embedded Linux systems for AArch64 and Arm platforms, including all TI Sitara processors (with the exception of AM62x-LP where TI does not provide official Buildroot support). Typical outputs include:

  • Bootable SD card images with TF-A, U-Boot, kernel, and root filesystem
  • Minimal root filesystems ranging from 10–50 MB for resource-constrained devices
  • Custom distributions tailored precisely to application requirements
  • Development SDKs with cross-compilation toolchains and debugging tools

Buildroot excels at creating focused, single-purpose systems where every component serves a specific function. It’s widely used in industrial controllers, IoT gateways, medical devices, and consumer appliances where cost optimization and deterministic behavior are paramount.

3. Build System Content

Buildroot provides a comprehensive framework consisting of:

Core Build Engine:

  • Makefiles and build scripts that orchestrate the entire build process
  • Kconfig-based configuration system (menuconfig, xconfig, gconfig)
  • Package infrastructure supporting multiple build systems (autotools, CMake, Meson, custom)
  • Filesystem generation tools (ext2/3/4, squashfs, ubifs, tar, cpio)

Package Collection (Buildroot 2024.08):

  • 3,000+ software packages covering common embedded needs
  • Libraries: OpenSSL 3.3, Qt 5.15 / Qt 6.7, GTK 3/4
  • Network services: dropbear, OpenSSH, lighttpd, nginx
  • Multimedia: FFmpeg 7.0, GStreamer 1.24, alsa-lib 1.2.11
  • System utilities: BusyBox 1.36, systemd 256

Toolchain Support:

  • Internal toolchain generation (GCC 13.3 cross-compiler)
  • External toolchain support (Linaro, Bootlin, vendor-provided)
  • Multiple libc options: glibc 2.39, musl 1.2.5, uClibc-ng 1.0.46

Configuration Management:

  • Board-specific defconfig files for quick starts
  • Filesystem overlay mechanism for custom files
  • Post-build, post-image, and post-fakeroot scripts
  • BR2_EXTERNAL mechanism for maintaining out-of-tree customizations

4. External Extensions

Buildroot supports external trees (BR2_EXTERNAL) that allow organizations to maintain board-specific configurations, packages, and customizations outside the main Buildroot tree. This enables:

  • Vendor BSP integration without forking Buildroot
  • Proprietary package inclusion alongside open-source components
  • Company-specific configurations maintained in separate repositories
  • Version control independent from Buildroot releases

5. Licenses

Buildroot itself is released under the GNU General Public License v2 (GPLv2). The licenses of the built software vary -each package maintains its own license.

SBOM and License Compliance Tools:

Buildroot 2024.08 supports CycloneDX SBOM generation natively

6. Community

Buildroot has an active, responsive community centered around pragmatic embedded developers.

Mailing List:

  • Primary channel: buildroot@buildroot.org
  • Typical response: hours to days for common questions
  • Searchable archives: lore.kernel.org/buildroot

IRC: #buildroot on Libera.Chat

Git repository: https://git.buildroot.net/buildroot

  • 4-month release cycle: February, May, August, November
  • LTS releases maintained for approximately 1 year

Bug tracking: bugs.buildroot.net

The community is known for pragmatic, focused discussions and a preference for simple, maintainable solutions. Patches are submitted via mailing list in the traditional kernel workflow style.

7. Configuration Syntax

Buildroot uses a Kconfig-based configuration language, identical to the Linux kernel’s configuration system.

make menuconfig          # Ncurses-based text interface
make xconfig             # Qt-based graphical interface
make savedefconfig       # Save minimal defconfig
make am62x-sk_defconfig  # Load TI board-specific configuration (via BR2_EXTERNAL)

Corrected defconfig snippet for AM62x (AArch64):

BR2_aarch64=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_TOOLCHAIN_EXTERNAL_DOWNLOAD=y
BR2_TOOLCHAIN_EXTERNAL_URL="https://toolchains.bootlin.com/downloads/releases/toolchains/aarch64/tarballs/aarch64--glibc--stable-2024.02-1.tar.bz2"
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_VERSION=y
BR2_LINUX_KERNEL_CUSTOM_VERSION_VALUE="6.6.44"
BR2_LINUX_KERNEL_DEFCONFIG="ti_sdk_am6x_release"
BR2_TARGET_UBOOT=y
BR2_TARGET_UBOOT_VERSION="2024.01"
BR2_PACKAGE_BUSYBOX=y
BR2_PACKAGE_DROPBEAR=y
BR2_TARGET_ROOTFS_EXT2=y
BR2_TARGET_ROOTFS_EXT2_4=y

The architecture token for 64-bit Arm is BR2_aarch64=y, not BR2_arm=y. Using BR2_arm=y silently selects a 32-bit Arm (AArch32) toolchain and will produce a non-booting image on AM62x.

8. Developer Experience

► Ease of Use

Buildroot is designed for developers who want results quickly without extensive build system expertise.

Quick Start:

  1. Clone repository and TI external tree
  2. Load board defconfig: make BR2_EXTERNAL=../buildroot-external-TI am62x-sk_defconfig
  3. Build: make
  4. Flash output/images/sdcard.img to SD card

Clean Mental Model: Select target hardware, choose packages, build from source. There are no layers, metadata, or complex abstractions to learn initially.

Predictable Behavior: Full rebuilds from clean state are deterministic.

► Limitations to Consider Honestly

  • No shared-state cache. Incremental builds are coarse-grained: touching a package triggers full package recompilation (42-minute clean build, 3-minute package rebuild in our measurements). Yocto’s sstate is faster for iterative development.
  • Package management ends at build time. Runtime apt/rpm/opkg is absent; any change requires a full rebuild and reflash.

► Learning Curve

  • Basic image build: 1–2 days
  • Custom packages via BR2_EXTERNAL: 1–2 weeks
  • BSP integration: 1–3 months

Yocto Project

1. What is Yocto Project?

The Yocto Project is a robust, open-source collaboration under the Linux Foundation that provides a comprehensive framework for building highly customized embedded Linux distributions. Founded in 2010, Yocto grew out of the OpenEmbedded Project to address the needs of commercial technology providers for greater stability, structured layering, sophisticated tooling, and licensing clarity.

Yocto Project is not a Linux distribution itself, but rather a build system and set of tools for creating custom distributions tailored to specific hardware and application requirements. At its core, Yocto uses the OpenEmbedded build system, BitBake, and a layered metadata architecture that provides unprecedented flexibility and scalability.

Figure 2: Yocto/OE Layer Architecture for TI Platforms

OE-Classic (legacy)          OE-Core/Yocto (current)
┌──────────────────┐         ┌──────────────────────────────────┐
│ Angstrom Distro  │         │           meta-arago             │
├──────────────────┤    ──►  ├──────────┬──────┬───────────────┤
│  Console image   │         │ graphics │ bsp  │  meta-vendorX │
│  Gnome image     │         │    ti    │kernel│  meta-intel   │
├──────────────────┤         ├──────────┴──────┤               │
│ Community mach.  │         │     meta-ti     │               │
│   TI machines    │         ├──────────────────┤              │
├──────────────────┤         │ meta-oe  meta-gnome             │
│   Host tools     │  X11    │ meta-efi meta-xfce              │
│   GCC toolchain  │  Qt     │ meta-gpe meta-openembedded      │
├──────────────────┤         ├────────────────────────────────┐│
│   Base image     │         │ oe-core (minimal shared pkgs)  ││
│  Minimal Distro  │         └────────────────────────────────┘│
└──────────────────┘         └──────────────────────────────────┘
Selected layer                    Optional layer

Texas Instruments is a corporate supporter and active contributor to the Yocto Project, with dedicated engineers maintaining the meta-ti layer and participating in project governance.

2. What Can Be Built with Yocto Project?

Yocto Project can build complete embedded Linux distributions for any architecture, from minimal headless systems to full-featured graphical environments. For TI Sitara platforms, Yocto supports:

  • Complete BSP distributions with kernel, bootloader, and optimized root filesystem
  • Product family variants sharing common layers with board-specific customizations
  • Multiple image types from single codebase (minimal, development, production, SDK)
  • Software Development Kits (SDKs) with cross-toolchains and sysroots for application development
  • Package feeds for runtime updates via package managers (rpm, deb, ipk)
  • Reproducible builds with complete source provenance tracking

3. Build System Content

BitBake Build Engine:

  • Task-based dependency resolution engine
  • Parallel build support for multi-core systems
  • Shared state cache (sstate-cache): hash-based change detection allows skipping unchanged tasks; critical for iterative development speed

OpenEmbedded-Core (OE-Core):

  • Minimal, validated set of core recipes (~200 packages)
  • Foundational classes (kernel, autotools, cmake, systemd)
  • Toolchain generation infrastructure

Package Universe (Scarthgap 5.0):

  • OE-Core: ~200 foundational packages
  • meta-openembedded: ~1,500 additional packages
  • meta-ti: TI-specific BSP and accelerator packages
  • Thousands of community layers available at layers.openembedded.org

TI Layer Stack:

LayerRoleRepositoryoe-coreBase packages, toolchaingit.openembedded.org/openembedded-coremeta-openembeddedExpanded packagesgit.openembedded.org/meta-openembeddedmeta-tiTI BSP, GPU, PRU, codecsgit.yoctoproject.org/meta-timeta-aragoTI reference distro configgit.arago-project.org/meta-arago

4. External Layers

BSP Layers: Hardware-specific configurations including machine definitions, kernel and bootloader recipes.

Distribution Layers: Distribution-wide policies such as package version pinning and init system choice.

Software Layers: Additional packages beyond OE-Core (meta-openembedded).

Application Layers: Company-specific applications and proprietary software integration.

bitbake-layers show-layers    # List active layers
bitbake-layers add-layer ../meta-custom
bitbake-layers remove-layer ../meta-custom
# Layer dependencies declared in layer.conf:
LAYERDEPENDS_meta-custom = "core meta-ti"

Texas Instruments Layers (wrynose, Oct 2026):

meta-ti (BSP layer):

  • Tag: ti-12.01.00
  • Supports: AM335x, AM437x, AM57x, AM62x-LP, AM62x-SIP, AM62x, AM62P, AM64x, AM65x
  • Provides: kernel 6.18.44-ti, U-Boot 2026.01, TF-A 2.24, OP-TEE 4.2.0
  • GPU: IMG PowerVR BXS-4–64 / BXE-4–32 (OpenGL ES 3.2, Vulkan 1.0 on AM62P)
  • Codecs: H.264/H.265 hardware decode via Video Codec Engine (VCE) on AM62x/AM62P
  • PRU: full firmware, remoteproc, and ICSSG ethernet support

meta-arago (Distribution layer):

  • Pins package versions to known-working combinations
  • Provides tisdk-default-image and tisdk-default-image-gui
  • SDK installer generation configurations

5. Licenses

Yocto Project and OE-Core are released under a mix of MIT License and GPLv2.

Get Sadikthanos’s stories in your inbox

Join Medium for free to get updates from this writer.

SBOM and License Compliance (Yocto’s major strength):

Yocto Scarthgap supports both SPDX and CycloneDX SBOM formats

The compliance output includes: all packages, their SPDX license identifiers, source archives, license texts, and package dependency graph -meeting requirements for IEC 62443, ISO 26262 (automotive SPICE), and EU Cyber Resilience Act (CRA) SBOM mandates.

6. Community

Governance:

  • Technical Steering Committee with representatives from Intel, TI, Wind River, and others
  • Denys Dmytriyenko (TI) serves on Yocto/OE Board of Directors
  • Formal release process: major release every 6 months (April, October)

Communication:

Documentation: docs.yoctoproject.org -comprehensive but dense (Mega-Manual exceeds 3,000 pages).

7. Recipe Syntax

BitBake recipes use a custom metadata language combining Python and shell scripting. The syntax has a steep learning curve compared to Buildroot’s Kconfig or Debian’s apt.

# meta-example/recipes-example/hello/hello_1.0.bb
SUMMARY = "Simple hello world application"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=abc123..."SRC_URI = "https://example.com/hello-${PV}.tar.gz \
           file://0001-build-fix.patch"
SRC_URI[sha256sum] = "abcdef123456..."DEPENDS = "libfoo"
RDEPENDS:${PN} = "bash"inherit autotools systemdSYSTEMD_SERVICE:${PN} = "hello.service"do_install:append() {
    install -d ${D}${systemd_system_unitdir}
    install -m 0644 ${WORKDIR}/hello.service ${D}${systemd_system_unitdir}
}FILES:${PN} += "${systemd_system_unitdir}/hello.service"

8. Developer Experience

► Ease of Use

Initial barriers:

  • Large initial download (several GB of source archives)
  • Long first build time (187 minutes in our measurements; see Methodology)
  • Requires high-end workstation: 8+ cores, 32+ GB RAM recommended, 100+ GB disk

Positive aspects:

  • sstate-cache: incremental rebuilds are very fast (28 seconds in our measurements vs. 3 minutes for Buildroot)
  • devtool and recipetool streamline recipe development
  • SDK generation creates standalone cross-compilation environments for application teams

► Learning Curve

  • Basic image build following TI docs: 1 week
  • Custom image with added packages: 2–4 weeks
  • Custom recipe development: 1–2 months
  • BSP development: 3–6 months

Organizations committing to Yocto should invest in professional training or dedicate an experienced engineer to mentor others.

Debian / Armbian

1. What is Debian/Armbian?

Debian is one of the oldest and most respected Linux distributions, founded in 1993. Debian provides a vast ecosystem of pre-built binary packages (over 59,000 in Bookworm) covering virtually every use case.

Armbian is a specialized Debian/Ubuntu derivative focused on ARM single-board computers and embedded platforms. Armbian maintains board support packages (BSPs) for hundreds of ARM devices, providing regular kernel and security updates.

For embedded systems, Debian/Armbian represents a distribution-based approach: developers start with a working binary base and customize by installing/removing packages, rather than building everything from source.

Texas Instruments Armbian Support:

ItemDetailRepositoryhttps://git.ti.com/cgit/armbian/armbian-buildBaseArmbian Bookworm 24.2Kernel6.6.44-ti-arm64U-Boot2024.01PlatformsAM62x-LP, AM62x-SIP, AM62x, AM62P, AM64x

2. What Can Be Built with Debian/Armbian?

Debian/Armbian is ideal for:

  • Rapid prototyping where development speed matters more than footprint optimization
  • Edge computing gateways running containerized applications
  • Industrial HMIs with full graphical environments
  • Development environments for application teams unfamiliar with embedded build systems
  • Systems with generous resources (512+ MB RAM, 4+ GB storage)

3. Distribution Content

Core System:

  • Linux kernel 6.6 LTS with broad hardware support
  • systemd 254 init system and service management
  • apt/dpkg package management
  • Standard Linux utilities (coreutils, util-linux)

Application Ecosystem:

  • 59,000+ packages in Debian Bookworm repositories
  • Docker, Podman containerization
  • Python 3.11, Node.js 20 LTS, Rust, Go
  • GStreamer 1.22, FFmpeg 6.0

4. External Repositories

Official Debian Repositories:

  • main: Free software (DFSG-compliant)
  • contrib: DFSG-free with non-free dependencies
  • non-free: Restrictive licenses

TI-Specific Packages (via TI Armbian fork):

  • TI Linux firmware (for PRU, ICSSG, MCU)
  • GPU firmware (IMG BXS/BXE PowerVR -proprietary binary)
  • Multimedia codec support
  • PRU tools and support packages
sudo apt update && sudo apt install -y \
  ti-linux-firmware \
  gstreamer1.0-tools gstreamer1.0-plugins-base \
  gstreamer1.0-plugins-good

5. Licenses

Distribution License: Debian Social Contract and DFSG -no cost, no restrictions on commercial use.

Compliance Considerations:

  • Individual packages have varying licenses (GPL, LGPL, BSD, MIT, Apache)
  • apt show <package> shows the license; dpkg --get-selections | grep ... inventories installed packages
  • No built-in SBOM generation (use syft, trivy, or bomber as third-party tools for CycloneDX/SPDX generation from installed packages)
  • GPL packages may require source code distribution in commercial products

6. Community

Debian community:

  • 1,000+ official Debian Developers worldwide
  • debian-user mailing list, debian-arm list for ARM-specific topics
  • #debian on OFTC; bugs.debian.org

Armbian community:

  • forum.armbian.com for board-specific support
  • Active BSP developers for hundreds of ARM boards

TI E2E Forums: https://e2e.ti.com for platform-specific questions with TI engineer participation.

7. Developer Experience

► Ease of Use

Debian/Armbian provides the fastest path to a working system:

  1. Download pre-built image from TI Armbian fork
  2. Flash to SD card with dd or balenaEtcher
  3. Boot and configure (5–10 minutes)
  4. sudo apt install whatever the application needs

No build system expertise required-standard Linux system administration skills transfer directly.

► Learning Curve

  • Linux-familiar developer: hours to productivity
  • Linux newcomer: a few days

Getting Started Guides

These quick-start guides are provided as starting points. Always consult the current TI Processor SDK release notes for the most up-to-date instructions, as specific commands and version numbers change with each release.

To get started on these distros for a single platform like Texas Instruments AM62X please refer the following sources-:
Buildroot-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03_Buildroot/exports/docs/devices/AM62X/buildroot/index.html
Yocto-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03/exports/docs/devices/AM62X/index.html
Armbian/Debian-:https://software-dl.ti.com/processor-sdk-linux/esd/AM62X/12_01_00_05_03_Debian/exports/docs/devices/AM62X/debian/index.html

1. Buildroot Quick Start

System Requirements:

  • Linux development PC (Ubuntu 22.04 LTS recommended)
  • 4+ CPU cores (8+ recommended)
  • 8+ GB RAM
  • 50+ GB free disk space

Step 1: Install dependencies

sudo apt install --no-install-recommends \
  sed make binutils build-essential gcc g++ bash patch \
  gzip bzip2 perl tar cpio unzip rsync file bc wget \
  libncurses5-dev git python3 python3-dev swig

Step 2: Clone Buildroot and TI external tree

git clone https://git.buildroot.net/buildroot
cd buildroot && git checkout 2026.05
cd ..
git clone https://git.ti.com/git/buildroot/buildroot-external-TI.git
cd buildroot-external-TI && git checkout main

Step 3: Configure for AM62x SK

cd ../buildroot
export BR2_EXTERNAL=$(pwd)/../buildroot-external-TI
make am62x-sk_defconfig          # exact defconfig name may vary; check TI release notes
make menuconfig                  # optional: customize

Step 4: Build

make -j$(nproc)
# Build artifacts: output/images/sdcard.img

Step 5: Flash

# Replace /dev/sdX with your SD card device
sudo dd if=output/images/sdcard.img of=/dev/sdX bs=4M status=progress conv=fsync

2. Yocto Quick Start

System Requirements:

  • Ubuntu 22.04 LTS
  • 8+ CPU cores (16+ recommended)
  • 32+ GB RAM
  • 150+ GB free disk space

Step 1: Install dependencies

sudo apt install --no-install-recommends \
  gawk wget git diffstat unzip texinfo gcc build-essential \
  chrpath socat cpio python3 python3-pip python3-pexpect \
  xz-utils debianutils iputils-ping python3-git python3-jinja2 \
  python3-subunit zstd liblz4-tool file locales libacl1 \
  libsdl1.2-dev
sudo locale-gen en_US.UTF-8

Step 2: Clone TI Processor SDK Yocto

mkdir -p ~/ti-yocto && cd ~/ti-yocto
git clone https://git.ti.com/git/processor-sdk/processor-sdk-linux.git
cd processor-sdk-linux
git checkout 12.01.00.04      # verify tag against TI release notes
git submodule update --init --recursive

Step 3: Initialize build environment

source oe-init-build-env build-am62x

Step 4: Edit conf/local.conf

MACHINE = "am62xx-evm"
# Alternatives: am62xx-lp-evm  am62pxx-evm  am64xx-evm
BB_NUMBER_THREADS = "16"
PARALLEL_MAKE = "-j 16"
SSTATE_DIR = "${TOPDIR}/../../sstate-cache"
DL_DIR     = "${TOPDIR}/../../downloads"

Step 5: Build

bitbake tisdk-default-image
# Images: tmp/deploy/images/am62xx-evm/

Step 6: Flash

cd tmp/deploy/images/am62xx-evm/
sudo bmaptool copy tisdk-default-image-am62xx-evm.rootfs.wic.xz /dev/sdX

3. Debian/Armbian Quick Start

Option A: Download pre-built image

Option B: Build from source

sudo apt install git
git clone https://git.ti.com/git/armbian/armbian-build.git
cd armbian-build
sudo ./compile.sh \
  BOARD=am62x-sk \
  BRANCH=current \
  RELEASE=bookworm \
  BUILD_MINIMAL=yes \
  BUILD_DESKTOP=no \
  KERNEL_CONFIGURE=no

Flash:

xz -dk Armbian_*_am62x-sk_*.img.xz
sudo dd if=Armbian_*_am62x-sk_*.img of=/dev/sdX bs=4M status=progress conv=fsync

First boot:

# Default credentials: root / 1234 (wizard forces password change on first login)
sudo apt update && sudo apt upgrade
sudo apt install ti-linux-firmware gstreamer1.0-tools gstreamer1.0-plugins-good
Embedded Linux
Yoctoproject
Buildroot
Debian
Embedded Systems

--

Sadikthanos
Sadikthanos

Written by Sadikthanos

0 followers
1 following

Help

Status

About

Careers

Press

Blog

Store

Privacy

Rules

Terms

Text to speech