Industry update — Researchers released OpenPCIe, a fully open-source PCIe Root Port controller in synthesizable Verilog that closes timing at 100 MHz on an AMD Xilinx Artix-7 while consuming under 6% of the device’s LUTs — lowering the barrier to building the host-side link that sits beneath an NVMe controller on the FPGA fabric (Applied Sciences (MDPI), 2026).
In short: connect an NVMe Host IP core to your FPGA over AXI by splitting the job in two — an AXI4-Lite control port for commands, and a wide AXI4-Stream or memory-mapped AXI4 data plane for the SSD payload.
You have chosen an NVMe Host IP core to give your FPGA modern SSD storage. Now comes the part every integrator actually does at their desk: wiring that core into the rest of the design. In practice that means connecting it over AXI — ARM’s AMBA AXI4 family, the de-facto on-chip interconnect on both AMD and Altera FPGAs. With PCIe Gen5 host support now shipping on the newest FPGA families, more teams are dropping NVMe host cores straight onto the fabric — and the AXI NVMe IP integration work still comes down to the same handful of interfaces. Get the two sides of that interface right — the control plane and the data plane — and the core drops in cleanly. Get the clocking or the backpressure wrong, and a perfectly good PCIe link stalls. This guide walks the integration pattern engineers really use.
The short answer
An NVMe Host IP core exposes two kinds of AXI interface: a narrow AXI4-Lite control port for registers (issue a command, set a buffer address, read status) and a wide data-plane port — AXI4-Stream for continuous flows, or memory-mapped AXI4 when the core is a DMA master — that carries the actual SSD payload. You wire the control port to a small state machine or soft CPU, wire the data port to your capture logic or a DDR controller through an AXI interconnect, align clocks (crossing domains with an async FIFO where they differ), and honour the VALID/READY handshake so neither side stalls. That is the whole integration.
The AXI interfaces in play
AXI4 is part of ARM’s AMBA specification and is the interconnect Vivado and Quartus generate around almost every IP block. It matters here because an NVMe Host core is delivered as a block with AXI ports, and knowing which flavour does what removes most of the integration guesswork. Three flavours appear on a typical core:
- AXI4-Lite — a lightweight, single-transfer subset with no bursts. It has five channels (write address, write data, write response, read address, read data), each governed by a simple
VALID/READYhandshake. Perfect for a register file: a few tens of addressable locations, one word at a time. - AXI4 (full, memory-mapped) — the same five-channel structure but with burst support, so a single address phase is followed by many data beats (up to 256 per burst). This is what a DMA-capable core uses when it is a master reading and writing buffers in shared memory such as DDR.
- AXI4-Stream — a stripped-down, address-less point-to-point channel. There is no read/write notion and no addressing at all: just a one-way flow of data beats qualified by
TVALID/TREADY, with optionalTLASTto mark packet boundaries. Ideal for a continuous recorder that pushes samples in order to one destination.
Every AXI channel shares the same golden rule: a transfer happens on a clock edge only when both VALID (the source has data) and READY (the sink can accept it) are high. That single handshake is the backbone of the whole integration, and most wiring bugs are a violation of it. The canonical description lives in ARM’s AMBA AXI Protocol Specification.
Control plane vs data plane
The single most useful mental model when integrating any storage core is to separate the control plane from the data plane. They have completely different traffic profiles, and conflating them is where designs go wrong. In the NVMe host cores we ship for AMD and Altera FPGAs, the control port is AXI4-Lite and the data plane is AXI4-Stream or memory-mapped AXI4 — the same split you should expect from any well-formed core.
Control plane — small, occasional, register-based
The control plane is how your logic tells the core what to do: initialise the link, identify the SSD, issue a read or write of a given logical block, hand over a buffer pointer, and check status or completion. This is a trickle of single-word accesses to a memory-mapped register set, which is exactly what AXI4-Lite is for. On the NVMe side, these registers ultimately drive the submission and completion queue mechanics — you write a command descriptor and ring a doorbell, the core posts a completion when the SSD is done. You never move bulk data here.
Data plane — wide, sustained, high-bandwidth
The data plane is where the payload actually flows to and from the SSD. It has to sustain the full link bandwidth, so it is always the wide interface — AXI4-Stream or memory-mapped AXI4 — never the Lite control port. In a high-speed recorder, capture logic streams beats straight into the core; in a buffered system, the core is a DMA master that pulls data out of DDR over full AXI4 and pushes it to the drive. Keeping this path fed at line rate is the entire performance game.
Working out which data-plane interface fits your capture architecture? A short technical conversation usually settles it fast.
Wiring it up, step by step
With the two planes clear, the integration follows a repeatable order. The specific port names come from your core’s datasheet, but the pattern is generic:
- Place the core on its PCIe subsystem. The NVMe Host core sits on top of the FPGA’s PCIe hard block. Instantiate that block for your target family first — it fixes the user clock the core’s data plane will run on. The exact hard-block wrapper differs per device; our Xilinx Zynq UltraScale+ integration guide walks one family end to end.
- Connect the control port. Wire the core’s AXI4-Lite slave port to an AXI master: a small FSM you write, a soft CPU, or a JTAG-to-AXI bridge for bring-up. This is how you will issue every command.
- Connect the data port. For streaming, attach your capture pipeline’s AXI4-Stream master to the core’s stream slave (writes) and/or the core’s stream master to your consumer (reads). For a memory-mapped design, connect the core’s AXI4 master through an AXI interconnect to your DDR controller.
- Resolve the clocks. Run the data plane on the PCIe user clock. Where your application logic uses a different clock, insert an AXI clock-converter or an asynchronous FIFO at the boundary — do not simply connect two clock domains together.
- Wire reset correctly. AXI uses an active-low reset (
ARESETN) that must be synchronous to its clock and held long enough for the core to initialise. Share the reset domain with the interconnect. - Bring up the control path first. Before any data flows, prove the register interface: read an identity/status register, then issue a single-block write and read it back. Only then scale up to sustained streaming. On every core we bring up, we prove this control path before a single data beat moves — it isolates control-plane bugs from data-plane bugs cleanly and saves days on the bench.
Signals and their roles
You do not hand-wire most of these — the tools connect matching AXI ports automatically — but knowing the role of each signal group is what lets you debug a stalled transfer in simulation or with an integrated logic analyser. This is the generic AXI signal vocabulary, not any core’s proprietary pinout:
| Signal group | Interface | Role |
|---|---|---|
AWADDR, AWVALID, AWREADY |
AXI4 / Lite | Write address channel — where a write is going, plus its handshake. |
WDATA, WSTRB, WVALID, WREADY |
AXI4 / Lite | Write data channel — the data beats and per-byte write strobes. |
BRESP, BVALID, BREADY |
AXI4 / Lite | Write response channel — the slave acknowledges the write completed (OKAY / error). |
ARADDR, ARVALID, ARREADY |
AXI4 / Lite | Read address channel — the address to read from, plus its handshake. |
RDATA, RRESP, RVALID, RREADY |
AXI4 / Lite | Read data channel — returned data beats and their status. |
AWLEN, ARLEN, xBURST, xSIZE |
AXI4 (full only) | Burst qualifiers — how many beats and what kind of burst; absent on AXI4-Lite. |
TDATA, TVALID, TREADY, TLAST |
AXI4-Stream | Data-plane flow — one-way payload beats; TLAST marks the end of a packet. |
ACLK, ARESETN |
All | Clock and active-low synchronous reset for the interface. |
Note the shape: the memory-mapped ports (Lite and full AXI4) split every access into independent address, data and response channels, while the stream port collapses to a single data channel. When you watch these in a waveform, a stalled transfer is almost always a VALID asserted while the matching READY stays low — the signal groups above tell you exactly which channel is blocked.
The pitfalls: CDC and backpressure
Two integration mistakes cause the large majority of “it works in simulation but stalls in hardware” reports. Neither is exotic; both are avoidable once named.
Clock-domain crossing (CDC)
Clock-domain crossing (CDC) is what happens when a signal generated on one clock is sampled on another. The NVMe core’s data plane runs on the PCIe user clock; your capture or processing logic frequently runs on a different clock. Connecting AXI signals directly across that boundary is a classic metastability bug — it may pass a short simulation and then fail intermittently on the bench. The correct fix is an explicit crossing: an AXI clock-converter IP or a dual-clock (asynchronous) FIFO between the two domains, with proper synchronisers on the handshake. Treat every clock boundary as a designed component, not a wire. General FPGA design methodology on this is well covered in AMD’s UltraFast Design Methodology Guide.
Backpressure
Backpressure is AXI’s flow control: a sink pulls its READY signal low to say “not yet.” That is a feature — but it means the two sides must agree on rate. On a write to the SSD, if your source cannot present valid data every cycle the core is ready, the command queues drain and throughput collapses; on a read, if your consumer cannot accept data as fast as the SSD delivers it, the core backpressures and the drive’s queues fill. The design answer is elastic buffering — a FIFO deep enough to absorb the rate mismatch — and honestly sizing your sustained rate rather than trusting a burst figure. Under-fed queues are the number-one reason a fast PCIe link underperforms, and the fix is upstream of the core, in how you feed it.
Where this pattern stops applying
The AXI-to-NVMe integration pattern is the right lens for most designs, but not all:
- Your core uses a native, non-AXI interface. Some IP exposes a proprietary or Avalon (Altera) streaming interface instead of AXI. The control-plane / data-plane split still holds, but the exact signals differ — read that core’s datasheet.
- You need a file system, not raw blocks. AXI wiring gets bytes to the SSD as logical blocks. If the media must be readable on a PC, you also need an exFAT File-System IP layer above the host core — a separate integration on top of this one.
- Your throughput is modest. If a single SATA link would carry your data, a SATA Host core is smaller and simpler; the same AXI integration principles apply with less logic. Our SATA vs NVMe comparison covers where the line sits.
- You are counting exact resources or timing. Bus widths, clock frequencies, latency and LUT/FF utilisation are specific to each core and FPGA family. Size them from the datasheet and your own timing closure — never from a generic figure.
In summary
Connecting an NVMe Host IP core to your fabric is, at heart, an AXI exercise. Split the job into a control plane (a trickle of AXI4-Lite register accesses that drive the NVMe submission and completion queues) and a data plane (a wide AXI4-Stream or memory-mapped AXI4 path carrying the payload at line rate). Wire the ports, align the clocks with a proper crossing, respect the VALID/READY handshake, and bring up the control path before you scale the data path. Do that and the AXI NVMe IP core integrates cleanly — leaving the two real hazards, clock-domain crossing and backpressure, as the things worth your attention.
Need an NVMe host or storage IP core for your FPGA? Our engineers ship production-proven cores for AMD and Altera devices.
Frequently asked questions
Which AXI interface carries the actual SSD data?
The bulk read and write payload rides an AXI4 or AXI4-Stream data-plane interface, chosen so the core can move whole bursts without per-beat handshaking overhead. AXI4-Stream is common for continuous recorder traffic because it is a pure flow of data beats with no address phase; a memory-mapped AXI4 interface is used when the core acts as a DMA master reading and writing your buffer memory. The small AXI4-Lite port is only for control registers, never for payload.
Do I need a soft CPU to drive the AXI control interface?
No. The AXI4-Lite control port can be driven by a small state machine in your own logic, or by a soft processor if you already have one. Because the register set is just a handful of memory-mapped locations — issue a command, point at a buffer, poll for completion — a lightweight hardware controller is enough. That is the whole point of a hardware NVMe host: the protocol stays in fabric, so no operating system or driver is required on the AXI side.
What clock should the AXI interfaces run at?
Follow the core’s datasheet and the PCIe subsystem it sits on; the AXI data-plane clock is typically tied to the PCIe user clock so that data crosses into the host core without an extra clock-domain crossing. Your application logic often runs on a different clock, which is exactly where an asynchronous FIFO or AXI clock-converter belongs. Do not assume a frequency — read it from the specific core and family you target.
How do I avoid stalling the NVMe command queues?
Keep the data-plane interface fed. On writes, present valid data every cycle the core asserts ready; on reads, accept data whenever the core presents it. Under-feeding the submission queue — starving the core of buffers or commands — is the most common reason a fast PCIe link delivers disappointing throughput. Size your buffering and your command-issue rate to the sustained data rate, not the burst figure.
Can I connect the AXI data path straight to DDR memory?
Yes, when the core is a memory-mapped AXI4 master it can read and write an AXI-connected DDR controller through the interconnect, so your capture logic writes to DRAM and the NVMe core drains it to the SSD. For a self-contained streaming recorder you can instead feed the core directly over AXI4-Stream and skip external DRAM on the storage path entirely — which one fits depends on whether you need a large elastic buffer.
Does AXI4-Stream or memory-mapped AXI4 give better throughput?
Neither is inherently faster; they suit different data flows. AXI4-Stream shines for continuous, in-order, single-destination data such as a sensor recorder, with minimal control overhead. Memory-mapped AXI4 is the right choice when the core must address arbitrary buffers in shared memory or coexist with other masters on an interconnect. Match the interface to your traffic pattern and both will saturate the link if kept fed.
How we write these guides: each one is drafted by the integration engineers who build and support our cores. We describe generic, spec-defined AXI behaviour and always defer exact bus widths, clock frequencies, latency and LUT/FF utilisation to the target core’s datasheet and your own timing closure — never to a made-up figure.
Need to integrate an NVMe Host core into your FPGA, or want us to scope the AXI plumbing end to end? Tell us your family, interfaces and sustained rate — we will point you to the right core or take on the integration.
- ARM — AMBA AXI Protocol Specification: the definitive reference for the AXI4, AXI4-Lite and AXI4-Stream channels and the VALID/READY handshake.
- NVM Express, Inc. — NVMe Specifications: the submission and completion queue model that the control-plane registers ultimately drive.
- AMD — UltraFast Design Methodology Guide (UG949): FPGA design guidance including clock-domain crossing and interface practice.
- PCI-SIG — PCI Express Specifications: the PCIe link the NVMe host data plane runs over, which sets the user clock the AXI data plane is aligned to.
