Introduction to Open Platform Firmware

Platform firmware development faces a fundamental challenge: every silicon vendor brings its own initialization model, configuration scheme, and implementation approach, placing the burden of integration on platform developers. The Open Compute Project (OCP) has launched a community initiative to address this fragmentation: Open Platform Firmware (OPF). This effort aims to make boot firmware more open, reusable, and vendor-agnostic.

A note on naming: the OCP community page refers to this project as Open Platform Firmware (OPF), while the GitHub repository and wiki where engineering work occurs use the name Open System Firmware (OSF). The two names are used interchangeably in documentation. OPF/OSF serves as the umbrella project, with active engineering conducted through two workstreams: openSFI and UPC.

Key highlights:

• Owner-centric: The core goal is to enable system owners to control their firmware—shifting authority to those who operate the hardware
• Open: A public OCP project open to participation from silicon vendors, firmware vendors, hyperscalers, and individual developers
• Vendor-neutral: Aims to define common interfaces rather than dictate proprietary implementations
• Two active workstreams: Open Silicon Firmware Interface (openSFI) and Unified Platform Configuration (UPC)
• Industry-backed: Contributors include AMD, Intel, ARM, AMI, Insyde, Google, Microsoft, HPE, IBM, 9elements, 3mdeb, and more

Own Your Firmware

OPF addresses a fundamental issue in platform firmware: system ownership. The initiative enables OCP system owners to control their firmware, including the ability to modify it and share modifications—including binary components—with other owners. This shifts the point of control from vendors to system operators.

OCP has reinforced this requirement through policy: beginning in March 2021, OCP badging for servers requires that systems support OPF.

OPF adopts a pragmatic approach: while the project is open source, it does not mandate that vendors deliver firmware in source form. Open source components are designed for straightforward integration into proprietary firmware images. This model has been demonstrated since 2017 by the LinuxBoot project, which integrates Linux into UEFI images as a UEFI driver.

Vendors can deliver OPF-compliant systems through two primary approaches:

• Full open source: firmware delivered in source form, buildable and installable by the owner, for example as implemented in IBM's Power 9 systems with OPAL firmware
• Binary but componentized: a binary image with components that can be modified, removed, or replaced, following the UEFI model

While full open source delivery is preferred, the specification accommodates binary componentized firmware. OPF is currently demonstrated in projects including LinuxBoot and OpenEDK2.

The Problem

Platform firmware design does not scale effectively across silicon diversity. Even when platforms share identical memory and I/O components, host SoC initialization remains dependent on vendor-specific architectures—such as AMD's openSIL and Intel's Firmware Support Package (FSP). No unified abstraction layer exists to enable code reuse across these implementations.

The consequences include ecosystem fragmentation, extended development cycles, and duplicated engineering effort across development, debugging, maintenance, and validation. This increases costs and reduces efficiency. OPF addresses these issues through standardization.

Workstream #1: Open Silicon Firmware Interface (openSFI)

The openSFI workstream's vision is to give the industry an open, scalable, and sustainable silicon firmware interface so that platform integrators and firmware vendors can integrate diverse silicon more easily.

The primary objective is to develop a unified, open-source Silicon Firmware Interface that bridges AMD's openSIL and Intel's FSP, enabling consistent cross-platform silicon initialization. This approach may also establish a foundation for architecture initialization beyond x86 in future phases.

The workstream objectives:

• Unify the silicon init interface: One open abstraction layer that bridges different vendor approaches
• Simplify platform integration: Fewer dedicated vertical teams managing separate silicon init workflows
• Enhance resource efficiency: Less redundant development, validation, and maintenance—better time-to-market
• Foster industry collaboration: Get silicon vendors, firmware developers, integrators, and hyperscalers to agree on a standard
• Ensure scalability: An abstraction level that accommodates current and future silicon architectures

Scope Definition

The workstream has clearly defined its scope and boundaries.

In scope:

• A common, open silicon firmware interface adoptable across multiple vendors
• A vendor-neutral Architecture Framework Specification to guide implementation
• Proof-of-Concepts to vet the proposed interface
• Alignment with the x86 Ecosystem Advisory Group (x86EAG) and OCP tenets
• Industry collaboration to drive adoption

Out of scope:

• Non-x86 ISAs—for now, the focus is strictly Intel and AMD x86 host SoCs (ARM, RISC-V, and Power are out)
• Merging all silicon init firmware into a single solution—the goal is a common interface, not a unified firmware implementation
• Non-host silicon like standalone accelerators, GPUs, NICs, and storage controllers
• End-to-end platform firmware stacks—openSFI is an interface spec, not a complete firmware implementation
• Dictating how vendors implement their underlying init firmware—only how they expose it

The workstream focuses on defining a standardized interface rather than implementing complete firmware stacks.

Specification

The workstream has released the openSFI Firmware Architecture Specification (FAS) v1.0. This document defines the proposed abstraction layer.

Workstream #2: Unified Platform Configuration (UPC)

While openSFI addresses silicon initialization, the Unified Platform Configuration Interface (UPCI) workstream addresses platform configuration. Platform developers managing GPIO tables, memory settings, and boot policies across multiple SKUs encounter significant complexity due to bespoke approaches.

UPC envisions an ecosystem with open, unified, and interoperable platform configuration—standard data formats and programming interfaces that minimize fragmentation and streamline customization for platform owners, silicon vendors, and firmware developers alike.

The workstream objectives:

• Standardize configuration data formats: Both text-based and binary formats for consistent platform customization
• Enable cross-vendor interoperability: An open framework so config data flows between silicon vendors, integrators, and firmware developers
• Support multi-SKU management: Define multiple SKU variations in a single configuration package (less redundancy, more maintainability)
• Facilitate firmware update migration: Smooth config transitions during firmware updates
• Allow runtime configuration overrides: Dynamic updates via management agents or config utilities—no firmware rebuild required
• Standardize configuration structures: Unified representations of things like GPIO settings, aligned with openSFI
• Provide a common access interface: Programming abstractions for access to config data

The runtime-override capability enables dynamic configuration modification without firmware rebuilds, addressing a significant operational requirement in firmware development workflows.

Project Scope

The OPF project scope encompasses:

• All processor architectures found in the web-scale data center
• Cloud operating systems
• Compute (general purpose plus AI/ML/FPGA), storage, and network devices
• Development and deployment tools
• Security features

How It All Fits Together

The project structure is summarized below:

Workstream	What It Does	Key Idea
openSFI	Silicon initialization	A common interface bridging AMD openSIL and Intel FSP
UPC	Platform configuration	Standard, vendor-agnostic config formats and access APIs

UPC explicitly aligns its configuration structures (GPIO, etc.) with openSFI. The two workstreams are designed to reinforce each other, aligning with the core OCP tenets of efficiency, scalability, sustainability, and openness.

Participation

OPF is a public OCP project that welcomes participation. Regular project calls, a GitHub wiki, governance documents, and an active contributor roster provide multiple avenues for involvement from across the industry.

Conclusion

Open Platform Firmware represents an ambitious effort to establish common silicon and configuration interfaces while restoring firmware control to system owners. This initiative is not new, it has been running since early 2021. IMHO, it's more of a philosophy than a real industry-standard, but it's worth exploring anyway. Additional resources for further investigation include:

OCP Open Platform Firmware project page: https://www.opencompute.org/community/open-system-firmware

OSF Wiki: https://github.com/opencomputeproject/OpenSystemFirmware/wiki

Open Silicon Firmware Interface (openSFI): https://github.com/opencomputeproject/OpenSystemFirmware/wiki/Open-Silicon-Firmware-Interface

Unified Platform Configuration (UPC): https://github.com/opencomputeproject/OpenSystemFirmware/wiki/Unified-Platform-Configuration

openSFI Firmware Architecture Specification (FAS) v1.0:
https://www.opencompute.org/documents/firmware-architecture-specification-opensil-v1-0-pdf

LinuxBoot project: https://www.linuxboot.org/