#Buildroot

[clevercyclecollectorfan]

How to Replace WiFi Driver on STM32MP1 Using Buildroot

In current project, I focused on replacing the existing outdated WiFi driver with an updated version driver provided by NXP. The target machine for this task is the STM32MP1, which utilises an ARM-based architecture. The challenge arose because the instructions in the driver’s README file were created for use on the target machine. They were specifically designed for building the driver directly…

[forlinx]

Hey all! 👋 Here's a quick rundown on T113 Buildroot cross-compilation toolchain replacement. 🛠️

1. Find the toolchain at OK113i-linux-sdk/out/t113_i/ok113i/longan/buildroot/host/bin/arm-linux-gnueabihf-gcc. Delete 'out' dir and decompress new toolchain from specific path.

2. Alter mkcmd.sh and mkcommon.sh as instructed.

3. In SDK path, do commands like./build.sh config (adjust for board), then set toolchain & target options in buildroot config.

4. Compile, fix errors if any, and after success, do full compile & image pack in SDK.

5. Test with a program.

[siliconsignalsblog]

Understanding the 4 Core Components of an Embedded Linux System

Before diving into how to build a complete embedded Linux system, it’s important to know what major parts make up the system itself. A good way to understand this is by looking at the boot process — what happens when you power on a device like an embedded controller, industrial gateway, or smart gadget.

Each component plays a specific role in bringing the system to life, step by step. Here's a simple breakdown of the four essential parts of an embedded Linux system:

1. 🧠 Boot ROM – The Starting Point Inside the SoC

The Boot ROM is the very first code that runs when you power on your embedded device. It’s stored in read-only memory directly inside the System-on-Chip (SoC) and is similar to the BIOS on a standard computer. Although it's locked and can't be changed, it can react to external configurations (like boot pins) to decide where to load the next stage from – such as an SD card, eMMC, NAND flash, or even over UART/serial.

Some Boot ROMs also support secure boot by only allowing signed software to load next, adding a strong layer of security to the embedded system.

2. 🚀 Bootloader – Initializing the Hardware and Loading the Kernel

After the Boot ROM finishes its job, it passes control to the Bootloader. In many cases, the bootloader itself runs in two steps:

First stage: Prepares the system by initializing the RAM (since it's not ready right after power-up).

Second stage: Loads the Linux kernel from a chosen storage device or over a network (useful during development via TFTP).

Modern bootloaders also include features to:

Flash firmware or kernels onto memory devices like NAND or eMMC,

Test hardware components like I2C/SPI, RAM, and others,

Run Power-On Self-Tests (POST) to ensure system stability before launching the OS.

Popular bootloaders like U-Boot are often used in embedded Linux development for their flexibility and wide hardware support.

3. 🧩 Linux Kernel – The Core of the Operating System

The Linux Kernel is the brain of the system and is responsible for:

Talking to the hardware (drivers for peripherals),

Handling system tasks like scheduling and memory management,

Creating a stable environment for your applications to run.

It acts as the bridge between the hardware layer and the user space, making it possible to develop portable embedded applications that don’t rely on the specifics of the underlying board.

4. 📁 Root File System – The Application Playground

Once the kernel is up and running, its next task is to mount the root file system — the place where all applications, scripts, and shared libraries live.

Creating this from scratch is complex due to package dependencies and compatibility issues. That’s why tools like Buildroot, Yocto Project, or OpenEmbedded are used to automatically build and manage the root filesystem.

These tools help embedded developers customize and maintain a lightweight and reliable file system tailored to their device, ensuring consistency and performance.

Need Help Building Your Embedded Linux Solution?

At Silicon Signals, we specialize in custom embedded Linux development, including board bring-up, device driver integration, Android BSPs, secure boot implementation, and real-time optimizations.

Whether you're working on a new product or looking to optimize an existing one, our team can help you accelerate development and reduce risk.

📩 Contact us today to discuss how we can bring your embedded system to life. 🌐 Visit: www.siliconsignals.io ✉️ Email: info@siliconsignals.io

[epsumlabs]

Board Support Package (BSP) Development - Epsum Labs

In the world of embedded systems, getting hardware and software to work together seamlessly is no small feat. That’s where the Board Support Package (BSP) comes in—a critical component that ensures your operating system (OS) communicates effectively with your hardware.

But what exactly is BSP, and why does it matter for embedded development? 

Let’s break it down step by step in simple terms.

What is a Board Support Package (BSP)?

Think of BSP as a bridge between hardware and software. It contains the essential drivers, configuration files, and bootloaders that allow an OS—like Linux—to run on a specific hardware platform.

Without it, your board is just an expensive piece of silicon!

Core Components of BSP:

✅ Bootloader – Wakes up the hardware and loads the OS into memory. ✅ Kernel & Device Tree (DTB) – Customizes the OS to recognize hardware features like GPIOs, buses, and memory. ✅ Device Drivers – Enables communication between the OS and peripherals (USB, Ethernet, Display, etc.). ✅ Root Filesystem (RootFS) – Houses system libraries, scripts, and utilities that run in user space. ✅ Board Configuration Files – Stores startup scripts and kernel configurations to define system behavior.

Step-by-Step BSP Development Process

Building a BSP isn’t just about writing code—it’s a structured process to ensure hardware and software integration. Here’s how it works:

🔹 Step 1: Hardware Bring-Up – Getting the board powered up and running. 🔹 Step 2: Bootloader Configuration & Debugging – Setting up the bootloader to initialize hardware correctly. 🔹 Step 3: Kernel & DTB Porting – Modifying the Linux Kernel and device tree to match the board’s hardware. 🔹 Step 4: Building the Root Filesystem (RootFS) – Creating the system environment using tools like Yocto or Buildroot. 🔹 Step 5: OS Bring-Up & Debugging – Testing and debugging system boot, drivers, and peripherals. 🔹 Step 6: Driver Development & Optimization – Customizing device drivers and improving boot times. 🔹 Step 7: BSP Finalization & Deployment – Packaging everything and deploying it onto the target board.

Each step ensures that your embedded system runs efficiently and reliably.

Read More on Board Support Package Development

[engineeringpu]

What are Embedded Systems | Dr. Anupam Sobti

The embedded systems course at Plaksha University is designed to provide insight into how electronic products are designed and manufactured. The course is divided into 4 parts:

Module 1: Power it Up: Starting from developing a deep understanding of how power supplies are designed and used, we do bare bones chip-level design. We build microcontroller based designs on our own printed circuit boards.

Module 2: Connect it together: We learn how to interface different types of peripherals with microcontrollers and the different types of interfaces that are used in embedded system design. We discuss both aspects - the computer architecture and the software design of the systems. We discuss the internal architecture design as well as software usage for the various modules in a microcontroller apart from the CPU - timers, interrupts, Analog to Digital Converters (ADCs). We end this module with a discussion of the state of the art devices built and a showcase that the underlying hardware remains surprisingly simple.

Module 3: Modularise and Sustain: Next, we discuss how a real-time operating system (RTOS) simplifies embedded software design and provides facilities for automatic virtualization and memory management. We see code examples from the popular FreeRTOS and Zephyr RTOS systems. We concluded this module by touching briefly on embedded linux - the world of yocto and buildroot.

Module 4: Add Magic: Finally, we see how machine learning is sprinkling magic into embedded systems and helping build devices of the future. Here, we explore the world of TinyML and bring together learnings from various courses - Foundations of Computer Systems, Machine Learning, Deep Learning, etc.

[embedded-hash]

Trending topic on Embedded Linux

🚀 Embedded Linux is Evolving! 🚀 5 Key Trends You Should Know: ✔ Real-Time Linux (RT-Linux) ✔ AI & ML on Edge ✔ Yocto & Buildroot ✔ Security & Hardening ✔ RISC-V Adoption Tech is moving fast—don’t get left behind!

[unidentifiedfuckingthing]

we got a raspberry pi 4 years ago at microcenter and had plans at the time but never ended up using it but im thinking of seeing if i can set up a buildroot on it and make it a ds line emulator

[hackernewsrobot]

Buildroot

https://buildroot.org/

[techvandaag]

Home Assistant OS 12.0

Versie 12.0 van Home Assistant OS is uitgekomen. Home Assistant OS is een minimaal, op Buildroot gebaseerd besturingssysteem dat het mogelijk maakt om op een fysieke of virtuele machine Home Assistant te draaien. In versie 12.0 is onder meer de Linux-kernel voor de meeste ondersteunde platforms bijgewerkt naar versie 6.6.16 en zijn verder de volgende veranderingen en verbeteringen aangebracht: Home Assistant Operating System http://dlvr.it/T3GtlQ

[govindhtech]

Five Linux Kernel Loading and Starting Methods

Understanding the Linux Kernel Running software requires virtualization. The target system boots and software build can affect this. Linux kernel binary loading was added to Intel Simics Quick-Start Platform. Installation of kernel variant images into disk images before virtual platform boot was previously inconvenient.

Imagine how a virtual platform system boots Linux and why it helps. More realistic virtual platforms make it harder to “cheat” to provide user convenience beyond hardware. The new Quick-Start Platform setup is convenient without changing the virtual platform or BIOS/UEFI.

Linux? What is it? A “Linux system” needs three things:

Linux kernel—the operating system core and any modules compiled into it. Root file system, or Linux kernel file system. Linux needs a file system. Command-line kernel parameters. The command line can configure the kernel at startup and override kernel defaults. The kernel’s root file system hardware device is usually specified by the command line. Kernel settings command. The command line can configure the kernel at startup and modify kernel defaults. Commands specify the kernel’s root file system hardware device.

On real hardware, a bootloader initializes hardware and starts the kernel with command-line parameters. Other virtual platforms differ from this process. Five simple to advanced virtual Linux startup methods are covered in this blog post.

Simple Linux Kernel Boot Common are simple virtual platforms without real platforms. They execute instruction set architecture-specific code without buying exotic hardware or modeling a real hardware platform. Linux can run on the Intel Simics Simulator RISC-V simple virtual platform with multiple processor cores.

Binary files from Buildroot boot RISC-V. Bootloader, Linux kernel, root file system image, and binary device tree blob required. Software development changes Linux kernel and file system, but bootloader and device tree are usually reused. Bootloaders, Linux kernels, and root file systems are typical.

The simulator startup script loaded target RAM with bootloader, Linux kernel, and device tree. The startup script determines load locations. Updates to software may require address changes.

Startup script register values give the RISC-V bootloader device tree and kernel address. Kernel command line parameters are in devices. To change kernel parameters or move the root file system, developers must change the device tree.

Images are used on primary disks. Discs support unlimited file systems and simplify system startup changes.

Immediate binary loading into target memory is a simulator “cheat,” but kernel handover works as on real hardware after bootloader startup.

Flow variations. If the target system uses U-Boot, the bootloader interactive command-line interface can give the kernel the device tree address.

Too bad this boot flow can’t reboot Linux. It cannot reset the system because the virtual platform startup flow differs from the hardware startup flow. Any virtual platform reset button is prohibited.

Directly boot Linux Kernels Bootloader skipping simplifies system startup. A simulator setup script must load the kernel and launch it. The bootloader-to-Linux interface must be faked by setup. This requires providing all RAM descriptors and setting the processor state (stack pointer, memory management units, etc.) to the operating system’s expectations.

Instead of building and loading a bootloader, a simulator script does it. Changes to the kernel interface require script updates. ACPI, a “wide” bootloader-OS interface, may complicate this script. The method fails System Management Mode and other bootloader-dependent operations.

Sometimes the fake bootloader passes kernel command-line parameters.

Real bootloaders are easier, says Intel Simics.

Booting from Disk Virtual platforms should boot like real hardware. For this scenario, real software stacks are pre-packaged and easy to use. Virtual platform software development is bad.

FLASH or EEPROM bootloaders are hardware. By providing code at the system “reset vector,” the bootloader starts an operating system on a “disk” (NVMe, SATA, USB, SDCard, or other interfaces) when the system is reset. Intel Architecture system workflow starts with UEFI firmware. System designers choose Coreboot or Slim Bootloader.

In Linux, GRUB or Windows Boot Manager may be needed for bootloader-OS handover. Normal software flow requires no simulator setup or scripting.

Note that this boot flow requires a bootloader binary and disk image. Hardware bootloaders are unexecutable.

Disk image includes Linux kernel and command-line parameters. Change command-line parameters by starting the system, changing the saved configuration, and saving the updated disk image for the next boot, just like on real hardware.

The virtual platform setup script shouldn’t mimic user input to control the target system during this booting method. Similar to hardware, the bootloader chooses a disk or device for modeled platform reset. Target and bootloader select boot devices. Find and boot the only bootable local device, like a PC.

For a single boot, interacting with the virtual target as a real machine is easiest. Scripting may be needed to boot from another device.

Virtual platforms run the real software stack from the real platform, making them ideal for pre-silicon software development and maintenance. Test proof value decreases with virtual platform “cheating”.

Change-prone Linux kernel developers may dislike this flow. Every newly compiled kernel binary must be integrated into a disk image before testing, which takes time. New Linux kernel boot flow enables real virtual platform with real software stack and easy Linux kernel replacement.

Network Boot Disks don’t always boot real systems. Data centers and embedded racks boot networks. Software upgrades and patches don’t require system-by-system updates, simplifying deployments. System boot from central server disk images.

The Intel PXE network-based booting standard. Instead of booting locally, PXE acquires the disk image from a network server. The network boot can load stronger binaries and disk images gradually.

The virtual platform FLASH loads firmware to boot the disk.

Building a virtual platform network is hard. Linking virtual platform to host machine’s lab network does this. IT-managed networks need a TAP solution to connect the virtual platform to the lab network. PXE booting uses DHCP, which struggles with NAT.

One or more machines connected to the simulated network that provides services is the most reliable and easiest solution. Servers ran on service system files with boot images. An alternative disk boot file system.

Target systems need network adapters and bootloaders to boot disks.

New Linux boot flow The new Linux Kernel boot flow for Intel Simics simulator UEFI targets can be described with this background. Similar to direct kernel boots, this flow starts with a Linux kernel binary, command-line parameters, and root filesystem image. The standard target setup uses UEFI bootloader-based disk boot.

Target has 2 disks. First disk’s prebuilt file system’s Intel Simics Agent target binary and GRUB binary are used. The second disk has disk boot-like root file system. Dynamically configured disk images can boot Linux from utility disks. Avoids RAM kernel placement issues.

Intel Simics Agent allows this. A simulator or target software drives the agent system to quickly and reliably move files from the host to the target system software stack. Agents send “magic instructions” directly to target software, simulator, and host. Although fragile and slow, networking could transfer files.

Intel Simics simulator startup scripts automate boot. The script uses kernel command-line parameters and binary name to create a temporary GRUB configuration file. The agent loads the host’s EFI shell script into the target’s UEFI. A script boots EFI shell.

The EFI shell script calls the agent system to copy the kernel image and GRUB configuration file from the host to the utility disk. Finish: boot the utility disk Linux kernel with GRUB.

Virtual platforms speed Linux kernel testing and development. A recompiled kernel can be used in an unmodified Intel Simics virtual platform model (hot-pluggable interfaces allow disk addition). No kernel disk image needed. Easy kernel command-line parameter changes.

Flexible platform root file system insertion. PCIe-attached virtio block devices are the default, but NVMe or SATA disks can hold disk images. Virtuoso PCIe paravirtual devices provide root file systems. A host directory, not an image, contains this file system content. Host-privileged Virtuous daemons may cause issues. Root file system is found by kernel CLI.

A disk image contains all UEFI boot files, so the platform reboots. UEFI locates a bootable utility disk with GRUB, configuration, and custom Linux kernel.

All target-OS dependencies are in the EFI shell script. Rewritten to boot “separable” kernels outside the root file system.

Just Beginning Although simple, virtual platform booting has many intricate methods. Always, the goal is to create a model that simulates hardware enough to test interesting scenarios while being convenient for software developers. Use case and user determine.

Some boot flows and models are more complicated than this blog post. Not many systems boot with the main processor core bootloader. The visible bootloader replaces hidden subsystems after basic tasks.

Security subsystems with processors can start the system early. General bootloader FLASH or local memory can store processor boot code.

The main operating system image can boot programmable subsystems and firmware. OS disks contain subsystem firmware. The operating system driver’s boot code loads production firmware in most subsystems from a small ROM.

Read more on Govindhtech.com

[hydralisk98]

Content study list for my 16^12 paracosm, for myself and you all sweet, sweet mutuals!

Inspirations

Halo Reach, Tron Legacy, Reverse 1999, Helluva Boss, Wolfenstein The New Order, The New Order / "TNO" (Hearts of Iron 4 total conversion mod), Civilization 5 Complete Edition, Civilization Beyond Earth Rising Tide, Stellaris, Ruby Gillman Teenage Kraken, Spiderverse?, 300, 300 Rise of an Empire, Marathon Infinity, The Legend of Zelda 1, Quake 1, Pokemon Black & White, Wakfu, A Bag Full of Apples, Rammstein, Sabaton, Powerwolf, Daft Punk, Cyberpunk 2077, Cyberpunk RED, Solarpunk (aesthetic optimism genre), Kaiserreich (Hearts of Iron 4 total conversion mod), GURPS, Pathfinder 2E, D&D 5E SRD (under the one offered Creative Commons license), OSR, FKR, XCOM Enemy Within, The Elder Scrolls 2 Daggerfall, Hypnospace Outlaw, Counter-Strike Global Offensive, SimCity 4, The Sims 2, Citizen of Rome Dynasty Ascendant, Crusader Kings II, Europa Universalis IV, Pathfinder Kingmaker, Pathfinder Wrath of the Righteous, Tyranny, Spore, Alpha Centauri, Total Annihilation, Half-Life 1, Portal 2, Cortex Command, The Anacrusis, Tacoma, Zachtronics, Ion Fury, INFRA, Factorio, Terraria, Portal Stories Mel, SOMA, Choice of Alexandria, Choice of Robots, Prince of Persia Sands of Time, The Stanley Parable (demo & full game), The Beginner's Guide, Logic World, MineTest, Superliminal, Tentlan, Paradise Lost, The Witness, Secret Little Haven, Wargroove...

Tools of the Trade (essentially much of the KDE Plasma 5.27 desktop environment and a couple more utils)

GIMP, Krita, Blender, Inkscape, OpenStreetMap, SweetHome3D, LibreOffice Suite, Fish (command-line shell), Es (command-line shell), Karbon, , QGIS, GPlates, GProjector, QOwnNotes, KdenLive, Kate, LabPlot, Qt Creator, Buildroot, Debian, Devuan, Celestia, Cosmonium, KDE Plasma, KDE Liquidshell, custom KDE Plasmoids, ZealOS, Parade, Left, Ronin, Dotgrid, Pilot, Orca, GNU Common Lisp, LibertyEiffel, GNU CMake, GNU CoreUtils, OpenMPT, FastTracker, Furnace Tracker, Bintracker, Kitty (terminal emulator), , KDE Plasma Mobile, KDE Kirigami, Marble, Alpaka, Glaxnimate, KAlgebra, Kalm, Klevernotes, Licentia, Kalendar, Discover, Thunderbird, Peruse, Vail, KTechlab, KUIViewer, Francis, Kommit, KGeoTag, Rolistream RPG Client, Choqok (Mastodon, Jami & the Fediverse?), Arianna, RKWard, Konqueror, KMPlayer, Plan, Tokodon, PlasmaTube, KDiff3, Keysmith, Alligator, ghostwriter, Kontrast, AudioTube, youtube-dl?, Weather, digiKam, KLettres, Picmi, KTurtle, Parley, Kolf, Minuet, Okteta, Subtitle Composer, KJots, Skrooge, KEXI, Tellico, KFloppy, K3B, Kaffeine, ISO Image Writer, KMyMoney, Calligra Suite, KStars, Kid3, Haruna Media Player, Krusader, Telly Skout, KRename, Kongress, Kasts, KDE itinerary, Artikulate, Rocs, Kig, Step, KNights, KMPlot, KMouth, Umbrello, KAppTemplate, Cervisia, KNotes, Clazy, KWordQuiz, Kwave, DragonPlayer, KAddressBook, Cantor, Kontact, Skanpage, KTouch, KOrganizer, KBackup, Timeshift, Falkon, KMag, KMail, KImageMapEditor, Akregator, KGeography, Elisa, Krfb, Konversation, KMix, KDevelop, KDebugSettings, Kleopatra, KTorrent, KRuler, Kompare, Sweeper, KRDC, Lokalize, KCharSelect, Skanlite, KDE Partition Manager, KGpg, Yakuake, KColorChooser, KFind, Filelight, KWalletManager, KCalc, Gwenview, SPectacle, KDE Connect, Konsole, Kdenlive, HakuNeko, Kavita, GeoHub, Back Of Your Hand, locus, OwnTracks, darktable, Pixelmator, Procreate, Clip Studio Paint EX, OpenToonz (also its Morevna Edition), enve, Firefox, LibreWolf, Synfig Studio, Pencil2D, Storyboarder, TupiTube, BountySource, SourceHut, Gitea, GitPrep, digiKam, RawTherapee;

[clevercyclecollectorfan]

How to Build NXP WiFi (mwifiex) Driver with Buildroot for STM32MP1: A Step-by-Step Guide

In current project, I focused on replacing the existing outdated WiFi driver with an updated version driver provided by NXP. The target machine for this task is the STM32MP1, which utilises an ARM-based architecture. The challenge was that the instructions in the driver’s README file were meant for building the driver directly on the target machine. However, due to the limited size and…

[forlinx]

🚀 Guide to Adding Python3-pip in OK3568 Buildroot!

Are you looking to enhance your OK3568 Buildroot setup? Check out our step-by-step guide on how to add the Python3-pip package. From modifying config files to troubleshooting common compilation errors, we've got you covered! 🔧✨

💡 Key Steps:

Modify Config.in to include Python3-pip.

Download and extract the package.

Use make menuconfig to select Python3 and pip.

Handle potential SSL errors effectively.

Get your development board ready for pip commands! 💻🔥

[www-vcan-cc]

Use the build root tool to make RV1126 IMG firmware

Use the buildroot tool to package the executable file you compiled into the firmware (img file) Introduce two common methods Method 1: Place the compiled executable file in the buildroot/board/rockchip/rv1126_rv1109/fs-overlay-sysv/etc/init.d directory of the sdk, and compile and package it all. For example, here I have put the compiled executable file test-app in the directory Next just need…

[viettuansvn]

Giới thiệu Router UXG-Pro

Các thiết bị cũ USG và USG-Pro chạy EdgeOS. Các thiết bị dựa trên kiến trúc ARM như UDM và có thể là UXG sẽ sử dụng hệ điều hành UniFi OS. Khả năng có phiên bản EdgeOS trên các thiết bị cũ dành cho UXG-Pro là không cao. UniFi OS là một bản phân phối Linux tùy chỉnh được xây dựng từ Buildroot Linux và tuân theo chuẩn Debian. 

Trong thông báo của Ubiquiti về UniFi OS - Một nền tảng chung cho tất cả các bộ điều khiển UniFi. Các tính năng chính bao gồm:

Quản lý tập trung người dùng/truy cập

Đăng nhập một lần với tất cả các bộ điều khiển

Kết nối từ xa và cổng đám mây mới

Cài đặt và quản lý dễ dàng các ứng dụng khác nhau 

Thiết bị đầu tiên được được sử dụng UniFi OS là UDM-Pro. 

[ourwitching]

Our favorite raft of otters is back at it again with another display of open source audio prowess as...