ARM Design Services: Cortex-M, Cortex-A and Custom SoC Architecture
You have narrowed your processor choice to ARM. Good decision — the ecosystem is unmatched, the toolchain support is deep, and the silicon options range from sub-dollar microcontrollers to multi-core application processors. But now the real work begins. ARM design services span hardware schematic capture, PCB layout, BSP bring-up, firmware architecture, and power optimization. Each layer introduces decisions that lock in performance, cost, and time-to-market.
Teams often pick a dev kit, prove a concept, and then discover that moving to a custom board means rethinking power rails, clock trees, memory interfaces, and debug access. We have guided dozens of products through this transition. The difference between a prototype and a production-ready ARM design lies in disciplined architecture work before the first schematic page.
ARM design services encompass the hardware and software engineering required to build embedded products around ARM processor architectures — from Cortex-M microcontroller firmware and Cortex-A Linux-based systems to custom SoC integration with proprietary IP blocks.
What Is Cortex-M and When Should You Choose It?
Cortex-M is Arm's microcontroller processor family, designed for real-time response, low power consumption, and deterministic interrupt latency. Cortex-M0+ targets the simplest, lowest-power applications. Cortex-M4 adds DSP instructions and optional floating-point. Cortex-M33 and Cortex-M23 add TrustZone security isolation, now common in connected IoT devices. Cortex-M7 brings superscalar execution and an optional single- or double-precision FPU, while the newer Cortex-M85 (2022) is now Arm's highest-performing Cortex-M, adding Helium vector processing for DSP and machine learning.
Choose Cortex-M when your product needs real-time control, runs on battery, operates without an operating system or with a lightweight RTOS, and ships in volume where every cent of BOM cost matters. Motor controllers, sensor nodes, wearable devices, and medical monitors typically fit this profile.
The Cortex-M ecosystem is enormous. STM32, NXP LPC and Kinetis, Microchip SAM, and Nordic nRF52, nRF53 and nRF54 families all use these cores. This diversity means you can find a part with the right peripheral mix, power profile, and package — but it also means evaluation paralysis without clear selection criteria.
What Is Cortex-A and When Does Your Product Need It?
Cortex-A processors are application-class cores with memory management units, multi-level caches, and multimedia capabilities. They run Linux, Android, or other rich operating systems and handle networking, graphics, video, and complex computation that would overwhelm an MCU.
Select Cortex-A when your product needs a full operating system, TCP/IP networking stacks, USB or PCIe connectivity, display output, or significant compute throughput. IoT gateways, industrial HMIs, medical imaging devices, and connected instrumentation commonly use Cortex-A processors from the NXP i.MX, TI Sitara, or Rockchip families.
The trade-off is complexity. A Cortex-A design requires bootloader development, kernel configuration, device tree specification, root filesystem construction, and driver validation. The software effort dwarfs that of a typical Cortex-M project. Power consumption is higher too, though aggressive sleep states and dynamic frequency scaling help.
Key Insight: The boundary between Cortex-M and Cortex-A is blurring. Cortex-M55 with Helium vector extensions handles lightweight ML inference. Cortex-A35 brings application-class capability to power budgets that overlap with high-end MCUs. Match compute demand to the core, not the marketing category.
When Does Custom SoC Integration Make Sense?
A custom SoC integrates an ARM core with your proprietary IP, specific peripheral mix, and optimized power domains on a single die. Instead of selecting an off-the-shelf MCU and adding external components, you define exactly what goes on-chip.
Custom SoC development follows several paths. Arm Flexible Access — including its free DesignStart tier for Cortex-M0, Cortex-M3 and Cortex-M23 — lets teams integrate Arm cores with licensed or custom IP and pay licence fees only at tape-out. Cortex-A cores are available through Arm's standard licences or Flexible Access; an architecture licence is only needed to design your own Arm-compatible CPU. Alternatively, Arm and its design partners offer semi-custom approaches where you configure a pre-verified subsystem.
The economic case for custom SoC depends on volume. Because NRE and mask costs are high, custom silicon usually only pays back at volumes of several hundred thousand to millions of units per year. Below that, standard parts are almost always cheaper. The development timeline of 18-36 months also means custom SoC is unsuitable for markets with short product lifecycles.
Architecture | Best For | Typical Timeline | Complexity |
Cortex-M0/M0+ | Ultra-low-power sensors, simple control | 4-8 months | Low |
Cortex-M4/M7 | Real-time control, DSP, rich peripherals | 6-12 months | Medium |
Cortex-A (off-the-shelf) | Linux, networking, displays | 8-14 months | High |
Custom SoC | High-volume differentiation | 18-36 months | Very High |
What Does ARM BSP Development Involve?
Board Support Package (BSP) development is the firmware and software layer that makes your hardware usable. For Cortex-M, this means startup code, linker scripts, peripheral driver libraries, and RTOS integration. For Cortex-A, it extends through bootloader, kernel, and device drivers to the application runtime.
A typical Cortex-M BSP includes:
Startup assembly for vector table, stack initialization, and clock setup
HAL or LL driver libraries for GPIO, UART, SPI, I2C, ADC, timers
CMSIS-Core and CMSIS-DSP integration for portable software
RTOS port configuration for task scheduling and interrupt handling
Flash programming algorithm and debug configuration
Cortex-A BSPs add U-Boot or TF-A bootloader porting, Linux kernel configuration, device tree source files describing hardware topology, and root filesystem construction with Buildroot or Yocto. Each peripheral needs a driver — either from the SoC vendor, mainline kernel, or custom implementation.
Need expert BSP development for your ARM platform? Our firmware development team brings up custom boards, ports RTOS and Linux, and validates the full hardware-software interface.
How Do You Optimize Power on ARM Platforms?
Power optimization is a primary reason teams choose ARM. But the architecture alone does not save power — disciplined design does. Start with the lowest core family that meets performance requirements. A Cortex-M0+ at 48 MHz draws microamps in sleep; a Cortex-A53 running Linux needs milliamps minimum.
For Cortex-M designs, optimization strategies include:
Sleep mode utilization: Enter deep-sleep modes (e.g. STM32 STOP or STANDBY) whenever the CPU is idle
Clock gating: Disable peripheral clocks when modules are inactive
Voltage scaling: Run at the minimum voltage for the target frequency
Peripheral DMA: Keep the CPU asleep during data transfers
For Cortex-A designs, Linux provides sophisticated power management through CPUFreq, CPUIdle, and runtime PM frameworks. big.LITTLE and DynamIQ configurations assign background tasks to efficiency cores and burst workloads to performance cores. Thermal management prevents throttling under sustained load.
By M Gopinaga Bharath, Technical Manager
Frequently Asked Questions
What are ARM design services?
ARM design services encompass the engineering activities required to build products around ARM processor architectures, including Cortex-M microcontroller firmware, Cortex-A Linux-based systems, and custom SoC integration. These services cover hardware design, BSP development, driver implementation, performance optimization, and power management for ARM-based embedded and IoT devices.
What is the difference between Cortex-M and Cortex-A processors?
Cortex-M processors are microcontroller-class cores optimized for deterministic real-time response, low power, and cost-sensitive applications. They run RTOS or bare-metal firmware. Cortex-A processors are application-class cores with memory management units, caches, and multimedia capabilities, designed to run Linux, Android, or rich operating systems in more complex embedded products.
When does a project need a custom SoC instead of a standard MCU?
A custom SoC becomes worthwhile when you need to integrate proprietary IP, achieve extreme power efficiency, reduce BOM cost at high volume, or differentiate through specialized accelerators. Below several hundred thousand units a year, standard MCUs or application processors are typically more economical. Custom SoC development requires significant upfront investment and 18-36 month development timelines.
What is involved in ARM BSP development?
BSP development for ARM platforms includes porting the bootloader, configuring the memory controller, implementing device drivers for peripherals, setting up interrupt handling, configuring clock and power management, and validating the hardware-software interface. For Cortex-A systems, it extends to kernel configuration, device tree definition, and root filesystem bring-up.
How do you optimize power consumption in ARM-based designs?
Power optimization on ARM platforms uses multiple techniques: selecting the lowest appropriate core family, utilizing sleep modes and clock gating, implementing dynamic voltage and frequency scaling, optimizing software to maximize idle time, and for Cortex-A designs, leveraging CPU hotplug and big.LITTLE heterogeneous processing to match compute demand with the most efficient core.
What RTOS options work best with Cortex-M processors?
FreeRTOS is the most widely used RTOS for Cortex-M due to its small footprint, broad ecosystem, and CMSIS integration. Other options include Zephyr for modern IoT security features, Eclipse ThreadX (now open source) for safety-certified applications, and RTX5 for tight Keil MDK integration. For hard real-time requirements, some projects use bare-metal scheduling or SAFERTOS.
How long does an ARM-based embedded product take to develop?
A Cortex-M based product typically takes 4-12 months from architecture to production-ready prototype. Cortex-A Linux-based products range from 8-14 months due to BSP complexity. Custom SoC projects extend to 18-36 months including silicon fabrication. Timeline depends on software complexity, certification requirements, and hardware integration challenges.
Comments