In embedded systems development, hardware performance is undoubtedly important, but the factor that truly determines whether a project can be rapidly deployed is often the maturity of the software ecosystem. For ARM-based industrial core boards running Linux, a well-crafted software ecosystem can compress development cycles from months to just weeks. This article takes EBYTE's industrial core board product line as a case study to explore how the software ecosystem serves as the "invisible engine" that accelerates product time-to-market.

From Zero to One: The Complete Boot Chain

An embedded Linux system undergoes a rigorous three-stage boot process from power-on to normal operation. An excellent software ecosystem provides complete source code for all three stages, enabling developers to customize with ease.

Stage 1: FSBL (First Stage Boot Loader)

Taking EBYTE's ECK10-13xA series as an example, TF-A 2.8.6 (Trusted Firmware-A) in the system source code serves as the FSBL. It initializes the most fundamental security environment and hardware, making it the very first program executed by the CPU.

Supplemental Professional Insight: TF-A implements the ARM Trusted Firmware specification, providing a secure boot chain from power-on reset. It establishes the Root of Trust (RoT), validates the next-stage bootloader's signature, and configures the TrustZone controller to partition secure and non-secure memory regions — essential for industrial applications requiring data protection and tamper resistance.

Stage 2: SSBL (Second Stage Boot Loader)

OP-TEE 3.19 and U-Boot 2022.10 constitute the SSBL. OP-TEE provides a Trusted Execution Environment (TEE) that safeguards critical operations such as cryptographic key management and secure firmware updates. U-Boot, the most familiar bootloader in the embedded world, is responsible for initializing DDR, networking, storage, and other critical peripherals, then loading the Linux kernel based on the configured boot parameters.

Supplemental Professional Insight: The OP-TEE + U-Boot combination enables a "secure + flexible" dual-stage design. OP-TEE runs in the ARM TrustZone secure world, isolated from the normal world OS, making it ideal for secure payment, digital rights management, and industrial protocol encryption scenarios.

Stage 3: Linux Kernel Booting

Once the first two stages complete successfully, U-Boot loads Linux Kernel 6.1.28 into memory and starts it. The kernel then initialitses the remaining hardware, mounts the root filesystem, and launches the init process.

Ecosystem Acceleration Value

The manufacturer provides complete source code for all three stages (TF-A, OP-TEE, U-Boot). This means developers do not need to write or port boot code from scratch. By simply modifying board-specific parameters in U-Boot — such as DDR timing, network PHY addresses, or boot media priorities — engineers can quickly generate a stable, secure boot system tailored to their custom carrier board design.

Plug-and-Play Driver Support: Eliminating Low-Level Debugging Struggles

In bare-metal development, even getting a single GPIO to toggle may require hours of datasheet study. On a core board with a comprehensive BSP (Board Support Package), this process is reduced to executing a few commands. The core value of the software ecosystem lies in providing production-ready drivers for all on-board peripherals.

Based on the system software resource tables from EBYTE's ECK10-13xA and ECK20-6Y28C series, the following "all-star" driver lineup is available:

Ecosystem Acceleration Value

These drivers are not empty stubs — they are mature, hardware-verified code that can be directly compiled into the kernel. When you need to enable an Ethernet interface on the core board, you no longer need to decipher hundreds of pages of register-level documentation from the processor manual. Instead, you directly leverage the manufacturer's validated GMAC or Ethernet driver module and focus on higher-level application development.

Supplemental Professional Insight: EBYTE's BSP follows the mainline Linux kernel approach where possible, ensuring long-term maintainability and community support. The drivers are tested across industrial temperature ranges (-40°C to 85°C) and undergo signal integrity validation, significantly reducing the risk of field failures.

Out-of-the-Box Filesystem and Development Tools

With the kernel and drivers in place, you still need a filesystem containing user-space programs and a mature set of development and debugging tools. This is the "last mile" of the software ecosystem.

Pre-Configured Filesystem

The ECK10-13xA series ships with XFCE desktop Ubuntu 18.04 system. This means that upon boot, you see a familiar graphical desktop environment — a massive productivity boost for HMI (Human-Machine Interface) or industrial tablet applications. Additionally, a Buildroot-based lightweight filesystem is provided for minimal and highly customized deployments.

The ECK20-6Y28C series comes with Ubuntu 20.04 and supports the Yocto Project build system, offering greater flexibility for building complex industrial Linux distributions.

Powerful Development Toolchain

Ecosystem Acceleration Value

Developers do not need to manually download and configure each tool. The manufacturer's SDK package delivers this integrated, pre-tested "family bundle." On Windows, you can use Win32DiskImager or balenaEtcher to create an SD card boot system with one click. On Ubuntu, you can immediately use the cross-compilation toolchain for application development.

Transparent Documentation and Technical Support

Code and tools form the "skeleton," but clear, detailed documentation is the "soul." A mature software ecosystem is always accompanied by documentation that answers both "why" and "how."

Documentation Architecture

Ecosystem Acceleration Value

When encountering issues during development, comprehensive documentation serves as the first line of defense, often leading to quick resolution. If documentation falls short, the manufacturer's responsive technical support forms the second line of defense. This closed loop of "code + documentation + support" substantially reduces the technical risk of project implementation.

Side-by-Side Software Ecosystem Comparison

Ecosystem Value Comparison

• ECK10 Series (STM32MP135): Built on the ST ecosystem with a newer kernel and a comprehensive secure boot chain (TF-A + OP-TEE). Ideal for projects demanding enhanced security, modern kernel features, and rich multimedia capabilities (integrated Mali-400 MP2 GPU for HMI).

• ECK20 Series (i.MX6ULL): Based on the NXP ecosystem, with a mature, battle-tested kernel version and the Yocto build system. Perfect for industrial applications requiring a deeply customized, complex Linux system with the broadest community support and longest track record of production deployments.

The value of an embedded core board is bounded by hardware performance at the bottom but defined by software ecosystem at the top. The core philosophy of a great Linux on ARM software ecosystem is to "do the hard work for the developer in advance." By providing complete boot code, validated drivers, pre-configured systems, and professional tools, it frees engineers from low-level hardware adaptation, allowing them to stop reinventing the wheel and instead drive a finely-tuned "development express" straight to the product launch finish line.

Choosing a core board is fundamentally about choosing a software ecosystem partner that accelerates your success

Frequently Asked Questions (FAQ)

Q1: Do EBYTE's core boards support upstream/mainline Linux kernel, or do they require a vendor fork?
A: EBYTE provides a full BSP package based on the official ST (STM32MP135) and NXP (i.MX6ULL) Linux SDKs, which are derived from mainline kernel sources. For ECK10 series (STM32MP135), the kernel 6.1.28 is an LTS version with upstream support, making it easier to integrate community patches. For most projects, the vendor BSP is recommended as it includes validated drivers and board-specific configurations.

Q2: Can I use Buildroot and Yocto interchangeably on the same core board?
A: ECK10-13xA series supports Buildroot by default, while ECK20-6Y28C series uses Yocto. While technically possible to switch build systems, it requires significant effort to port the BSP layer. For optimal support, it is recommended to use the build system that comes pre-validated with the board. EBYTE provides detailed migration guides for advanced users who wish to switch.

Q3: How long does it typically take to bring up a custom carrier board with EBYTE's core boards?
A: With EBYTE's complete hardware design files (schematics, PCB footprints, layout guidelines) and validated BSP, an experienced hardware engineer can typically complete a custom carrier board design and bring-up in 2-4 weeks, compared to 3-6 months for a full custom design from scratch.

Q4: What if I need to use a newer kernel version than what is provided in the BSP?
A: EBYTE periodically releases BSP updates aligned with ST/NXP official SDK releases. If you require a kernel version newer than the official BSP, EBYTE's engineering team can provide custom BSP development services for volume customers. Alternatively, the mainline Linux kernel has growing support for STM32MP1 and i.MX6ULL platforms, allowing community-driven upgrades.

Q5: What is the difference between the Ubuntu desktop image and the Buildroot image for ECK10 series?
A: The Ubuntu 18.04 XFCE image provides a full desktop environment with package management (apt), making it ideal for HMI applications, rapid prototyping, and developers familiar with desktop Linux. The Buildroot image produces a minimal root filesystem (as small as 16MB), optimized for headless industrial applications, faster boot times (under 5 seconds), and reduced flash storage requirements.

Q6: Do EBYTE's core board BSPs include real-time support (PREEMPT_RT)?
A: The standard BSP uses the mainline kernel with the PREEMPT option enabled. For hard real-time requirements, EBYTE offers custom BSP configurations with the PREEMPT_RT patch set for qualified volume customers. Alternatively, the STM32MP135 features a dedicated Cortex-M4 coprocessor (on some variants) that can handle real-time tasks independently from the Linux-running Cortex-A7.

Q7: What long-term support and maintenance can I expect for the software BSP?
A: EBYTE commits to 3+ years of BSP maintenance for released core board products, including critical security patches, kernel CVE fixes, and toolchain updates. The underlying STM32MP1 and i.MX6ULL processors are backed by 10+ year supply guarantees from STMicroelectronics and NXP respectively, ensuring long-term product lifecycle support.

Q8: How do I perform Over-The-Air (OTA) firmware updates on EBYTE core boards?
A: EBYTE provides application notes and reference implementations for OTA updates using:

• SWUpdate (open-source): For A/B dual-copy update strategy on ECK10 series

• Mender or RAUC: For advanced OTA with rollback capabilities

• Custom OTA solutions based on MQTT/HTTP can be developed using the networking drivers provided in the BSP

Q9: Are there any benchmark or performance comparison data available for these core boards?
A: Typical performance benchmarks for the ECK10-13xA (STM32MP135 @ 1GHz):

• CoreMark: ~2.1 CoreMark/MHz

• Linux Boot Time: ~8 seconds (Buildroot image) / ~25 seconds (Ubuntu desktop)

• Network Throughput: ~940 Mbps (Gigabit Ethernet, hardware offload enabled)

• Power Consumption: ~0.8W (idle) / ~1.8W (full load)

Contact EBYTE technical support for comprehensive benchmark reports covering specific use cases.

Q10: What are the licensing implications for using the BSP source code in commercial products?
A: The BSP follows open-source licensing:

• Linux Kernel: GPLv2

• U-Boot: GPLv2

• TF-A: BSD-3-Clause

• OP-TEE: BSD-2-Clause

• Buildroot/Yocto layers: GPLv2 with commercial-friendly exceptions

• EBYTE board-specific drivers: BSD-style license allowing royalty-free use in commercial products

  
  

No license fees are required for using the BSP in commercial products, provided the terms of the respective open-source licenses are respected (typically requiring distribution of source code for GPL components if the product ships with them).