
Summary: GPUs and accelerators get the spotlight, but whether an AI server boots and can be managed depends on a set of peripheral ICs on the motherboard and management modules. These ICs hold the BIOS, BMC firmware and configuration data, and every one of them must be programmed and verified in production.
Conversations about AI servers almost always center on GPUs, accelerators and HBM.
Yet when a server powers on and joins a data center fleet, the first line of code doesn't run on a GPU. The BIOS lives in SPI NOR Flash on the motherboard. The BMC firmware sits in flash on the management module. A CPLD controls the power-up sequence, and board information is stored in EEPROM. These ICs are inexpensive and easy to overlook. But if any one of them is programmed with the wrong version, the server won't boot, or it boots but can't be managed.
This article sets the AI ICs themselves aside and asks a different question. As AI server hardware grows more complex, which ICs on the motherboard and peripheral modules need programming, and what should manufacturers watch for in volume production?
According to a TrendForce forecast released in January 2026, global AI server shipments are expected to grow 28.3% year over year in 2026. Total server shipments, including general-purpose servers, are expected to rise 12.8%.
Two points stand out for engineering teams. First, AI inference workloads are driving the refresh and expansion of general-purpose servers, so growth isn't confined to GPU racks. Second, the share of AI servers built on custom ASICs is expected to climb to 27.8%, which means the number of platforms keeps growing.
More platforms mean more motherboard designs, more management modules and more firmware versions. On the production line, that can mean more part numbers to program, more firmware files to manage and more frequent changeovers.
AI training and inference demand ever-higher data throughput, which is driving upgrades in both storage and interconnects. Inside the server are SSDs and storage backplanes. Between nodes are high-speed NICs and switches. Along the links, there may also be retimers, clock devices and other supporting ICs.
Each of these devices and boards has its own controller, and some of them need firmware or configuration parameters written during production. Exactly which ICs are involved, and what gets written, depends on the relevant datasheets and the product design.
Server management, security and control functions are moving off the motherboard. The Open Compute Project (OCP) DC-SCM (Datacenter-ready Secure Control Module) specification consolidates common management and security functions, such as the BMC and root of trust, onto a standard form-factor module. The same module can then be reused across server platforms.
Take a publicly documented DC-SCM 2.0 module from Flex as an example. It carries an AST2600 management controller, a CPLD, a root of trust (RoT) module and a TPM. It also includes dual 256MB QSPI NOR Flash devices for BMC firmware and dual 64MB QSPI NOR Flash devices for BIOS images.
This is one product, not a template for every server. But it makes the point clearly: a single management module can carry several ICs that need firmware or configuration data.
The same trend shows up on the management software side. openUBMC is an open-source BMC project. Its general hardware management component treats firmware for MCUs, VRDs (voltage regulators), CPLDs, FPGAs, retimers and security modules as managed objects, and stores board self-description data in the board EEPROM. The component also provides a dedicated manufacturing test interface for production environments.
This firmware can be updated in the field through the BMC. The initial version, however, must still be written and verified during production. The more firmware objects there are, the more programming paths and versions the line has to manage.
Not every IC in a server needs to be programmed individually. Whether a device needs program code or configuration data depends on its function, the board design and the manufacturing flow. The table below summarizes common cases in server hardware. Actual requirements depend on the platform design.
| Device Type | Typical Location | Typical Content | Production Focus |
|---|---|---|---|
| SPI NOR Flash | Motherboard, management module, some expansion cards | BIOS/UEFI, BMC firmware, boot and recovery images | Capacity, version matching, verification |
| EEPROM | Motherboard, power supplies, backplanes, various boards | Board info, serial numbers, MAC addresses, configuration parameters | Per-board unique data, address ranges |
| MCU | Power supplies, fans, backplanes, expansion modules | Bootloader, application firmware, calibration data | Part number match, offline vs. on-board programming |
| FPGA / CPLD | Motherboard, management module, accelerator cards | Logic configuration files | Configuration method, file version |
| Other controllers | Power, interconnect links, networking and storage | Firmware or configuration parameters | Programming path and device support |
BIOS/UEFI and BMC firmware are typically stored in SPI NOR Flash. The OCP RunBMC specification defines the interface between the BMC subsystem and the server platform, and includes a dedicated firmware SPI section. OCP community materials describe a typical BMC subsystem that uses two SPI NOR Flash devices for BMC firmware and two for BIOS firmware.
A primary/backup pair means both devices must be programmed, and their versions must match. In volume production, they can be programmed offline before placement or in-system through board-level interfaces after soldering. The right choice depends on where the flash sits, whether its interface is accessible and what the production process requires.
EEPROMs hold data that must survive power loss. Examples include FRU (field-replaceable unit) information, board model, manufacturing data, serial numbers, MAC addresses and configuration parameters.
Most of this isn't firmware. It is product identity and manufacturing information, and it often differs from board to board. Programming therefore goes beyond confirming a successful write. The content, address range and data format must all be checked to avoid overwriting existing data, and every record must match the production system.
Fan control, power status monitoring, sensor data acquisition and local control of backplanes and expansion modules may each be handled by a dedicated MCU that communicates with the BMC.
In production, these MCUs may need a bootloader, application firmware, configuration parameters or calibration data, typically written over JTAG, SWD, UART or SPI. Whether to program offline or on-board depends on whether the MCU is already soldered, whether its interface is accessible and what the process requires.
Server power-up involves sequencing multiple power rails and managing reset logic, a job often handled by a CPLD. FPGAs take on more complex board-level logic, interface management and signal processing. The OCP Project Argus DC-SCM 2.0 design specification lists CPLD firmware as a separate item.
Unlike MCUs, which receive firmware, FPGAs and CPLDs are programmed with logic configuration files. Some are programmed directly over JTAG. Some store their configuration in external SPI Flash. Others use vendor-specific configuration methods. FPGAs and CPLDs cannot all be handled with the same process.
Retimers in high-speed signal paths, digital power controllers (VRD/VR), and some networking and storage controllers may also require firmware or parameter programming. OCP community server motherboard specifications include sections on how the BMC accesses and updates CPLD and VR firmware.
Interfaces, data formats and programming flows vary widely across these devices. Whether a universal programmer can program them in production must be confirmed against the device support list and datasheet for the specific part number.
Important: These are typical categories of devices that may require programming in AI servers and related boards. Server configurations vary, and not every device needs to be programmed with an external programmer during production.
Once the target devices are identified, the next questions are: Is each device already soldered? Are its interfaces accessible? What is the volume? What does the process require? Four methods are common in server production.
The device is placed in the appropriate socket, programmed and verified before it goes onto the board, and then sent to SMT. This suits SPI NOR Flash, EEPROMs and some MCUs with finalized firmware and high volumes. Its advantages:
No dependence on programming interfaces on the target board
Fits into pre-SMT material preparation
Centralized management of firmware versions and programming jobs
Multiple sockets can run in parallel
The trade-off: if the firmware changes, any pre-programmed inventory must be dealt with. Before deployment, confirm that the part number, package, pinout, operating voltage and programming algorithm all match.
The device is already mounted on the motherboard, BMC module or expansion card. It is programmed at a test station through JTAG, SWD, SPI, I²C, UART or other interfaces. This approach is common for FPGAs/CPLDs, EEPROMs that need per-board data, and projects where firmware is still changing.
ISP isn't plug-and-play. Before deployment, confirm at a minimum:
Interface definitions and communication protocols of the target device
Power and signal level conditions on the target board
Reset, boot mode and access permissions
Signal isolation between multiple devices on the same bus
Recovery and exception handling after a failed programming cycle
On boards with multiple devices in particular, define the programming sequence and target selection logic clearly. This prevents writing to the wrong device or affecting other devices.
Offline, this means multiple sockets working at the same time. In-system, it means multiple channels programming several boards or devices simultaneously. But channel count doesn't equal throughput. Throughput also depends on:
Whether each channel can truly run independently in parallel
Whether part numbers and programming algorithms are identical
Data size, write time and Verify time per device
Socket loading/unloading or fixture docking time
Job scheduling
Sometimes a single part number runs in high volume and manual handling becomes the bottleneck. In that case, an automated programming system can handle feeding, pick-and-place, alignment, programming, verification and unloading. It supports tray, tape or tube input depending on the packaging.
Know the boundary: Offline automated programming handles devices before placement. Board-level ISP handles devices that are already soldered. The two solve different problems. If the device is already on the board, evaluate an ISP solution first instead of forcing an offline automated system into that role.
A single server often uses several methods at once. The BIOS flash may be programmed offline, the CPLD on-board, and the per-board EEPROM data at the functional test station. Assigning each device to the right process step matters more than committing to any one method.
During sampling, the question is whether the data can be written at all. In volume production, the focus shifts to stability, efficiency, version control and data management.
Server projects often qualify multiple Flash and EEPROM suppliers as alternates. Even within the same series, devices may differ in capacity, package, pinout or silicon revision. When selecting devices or qualifying alternates, check each of the following:
Full part number
Package and pinout
Operating voltage and interface type
Corresponding programming algorithm and supported version
Don't assume programmer support based on brand or series name. Don't extrapolate validation results from similar part numbers either.
A successful write isn't necessarily a correct one. Program writes the data; Verify checks the result. The BIOS, BMC firmware and board control code determine whether a machine boots properly, so verification must never be skipped.
Choose the verification method based on device characteristics and customer requirements: full data comparison, checksum or another supported mechanism. BIOS and BMC firmware images are large, so Verify time is significant. A schedule planned on write speed alone will be overly optimistic.
Running the same SPI NOR Flash job independently on multiple channels can shorten overall processing time. However, job scheduling and configuration management become more complex when different devices require different programs, voltages or flows.
If the bottleneck lies in loading/unloading, testing or another process, adding channels won't raise output proportionally. Evaluate multi-site solutions with real devices and real data sizes under full load.
A single server platform often carries multiple firmware sets. Different customers, configurations and validation stages each have their own BIOS and BMC versions. The motherboard, management board, storage boards and expansion modules also each have their own firmware. Establish clear production controls:
A defined list mapping each product model to its firmware version
Version identifiers and access control for program files
Strict separation of release, test and temporary versions
One-to-one mapping between programming jobs and production lots
Records of programming failures and rework
Firmware security is also raising the bar. NIST SP 800-193, Platform Firmware Resiliency Guidelines, provides technical guidance on protecting, detecting and recovering platform firmware, including the BIOS. Firmware that involves secure boot, signature verification or vendor authorization must follow the programming and verification flow specified by the platform vendor. A programmer that can write data does not necessarily provide complete firmware security management.
Programming results shouldn't end as a pass/fail message on the equipment screen. Depending on production management requirements, records may include:
Device part number and target board information
Firmware file and version
Programming time and verification result
Station and equipment information
Exceptions and rework status
Serial numbers, MAC addresses and board information in EEPROM must match the production records in MES one-to-one. MES integration depends on the equipment interface, the software features and the customer's system architecture, so the interface must be validated before deployment.
AI servers involve many device types. Some are memory devices programmed offline before placement; others are controllers programmed through board-level interfaces after soldering. Different processes call for different solutions.
The ALL-1000G is designed for SPI NOR Flash, EEPROMs, MCUs and other devices. According to current product documentation, the ALL-1000G Series uses a dual-system architecture with an independent MCU and Flash, and supports different devices and packages through Pin Cards.
For offline programming of devices for server motherboards and peripheral boards, sockets, adapter configurations and programming algorithms can be selected by part number. A single platform can then handle multiple device types, which reduces the management burden of scattered equipment and changeovers. It also suits lines with multiple qualified alternates and frequent changeovers. Supported devices are subject to the official HILOMAX device support list.
The ALL-1000ISP is designed for applications that require programming on the target PCB or system. According to current product documentation, the ALL-1000ISP Series covers JTAG, SWD, SPI, I²C and UART target interfaces, as well as USB and ATE applications.
MCUs, flash devices, CPLDs and other devices that need programming after soldering on server motherboards, management boards and expansion cards are good candidates for an ISP solution. Deployment should be validated against the target board's electrical conditions, interface definitions and programming sequence.
According to ALL-ISP product documentation, the series includes three models, the ALL-ISP-2, ALL-ISP-4 and ALL-ISP-8, which provide 2, 4 and 8 parallel programming sites respectively. All channels program simultaneously rather than through time-division multiplexing. Supported device types include MCUs, CPLDs and serial/parallel memory. Programming protocols cover JTAG, SWD, UART, SPI/QSPI, I²C and other common interfaces, as well as BDM, SWIM, ICSP, PDI, UPDI, SBW and custom protocols.
Features most relevant to server board-level programming:
Signal levels and power: ISP signal voltage is adjustable from 1.6 to 5.5 V with 100 mV accuracy. A built-in programmable power supply (PPS) offers a 1.6–5.5 V range with 100 mV resolution, with one PPS channel per programming site.
Line integration: Designed for ATE and fixture integration. The documentation lists compatibility with Keysight, Teradyne, TRI, SPEA, SEICA and other test systems. Supports both standalone operation and host control.
Host interfaces: Isolated USB (Full-Speed), LAN (100 Mbit/s) and RS-232, with EOS/ESD-protected I/O.
Software and integration: ASCII command set, DLLs and function libraries. The SDK supports C#, C, C++, LabVIEW, Python, Java and Visual Basic. Tools include a file manager, file merging and version backup/restore. The documentation also lists MES integration.
ALL-ISP is worth evaluating when a board carries multiple identical controllers, or when board-level programming must run in volume at ATE or functional test stations. Evaluation should consider the number of targets, interfaces and electrical conditions. Parallel channel count does not directly equal line throughput. Specific device and protocol support is subject to the device support list, and all specifications are subject to the official specifications of the relevant model and project validation results.
The AT3 Series is designed for high-volume processing of devices before placement and for reducing manual loading and unloading. It includes the AT3-150C, AT3-350C and AT3-350M4, which differ in socket count, pick-and-place structure and station configuration. AT3-350C documentation also covers 3D vision, laser marking and MES-related configurations.
Before deciding on automated programming, answer five questions:
Will the devices be programmed before they are soldered to the PCB?
What is the target device's package and feeding format?
What is the lot size and target UPH?
Are model changeovers required?
Is integration with MES or a host PC required?
If the devices are already soldered to the board, evaluate board-level solutions such as the ALL-1000ISP and ALL-ISP first.
Interfaces, channels, throughput and feature configurations for all of the above series are subject to the official specifications of the relevant models and project validation results.
An AI server's performance is determined by its GPUs and accelerators. Whether it boots reliably, can be properly managed and can be traced when problems arise depends largely on the SPI NOR Flash, EEPROMs, MCUs, FPGAs/CPLDs and other controllers behind the BMC.
These devices aren't all programmed the same way, and not all of them need an external programmer in production. But platforms, firmware versions and alternate parts are all multiplying. As a result, peripheral IC programming is evolving from a minor station on the line into a process step that must be planned in advance.
Evaluate programming solutions in this order: identify the devices, choose the programming method, then assess the volume production flow. The part number determines compatibility. The programming interface determines implementation. Takt time and data management determine whether the solution fits real-world manufacturing.
The earlier these questions are answered, the smoother the production ramp.
Need to evaluate programming solutions for devices on AI server motherboards, management boards or storage equipment? Contact HILOMAX. Share your part numbers, package types, programming interfaces, firmware version plan and line layout, and we'll help you confirm the right product configuration.
Next in this series: automotive electronics, and how programming in controller production meets consistency and traceability requirements.
