NVMe Host IP on Xilinx Zynq UltraScale+: Integration Guide

NVMe Host IP on Xilinx Zynq UltraScale+: Integration Guide

Industry update — Micron has moved its 9650 SSD, the industry’s first PCIe Gen6 data-center drive, into mass production, pushing sequential reads to 28 GB/s and 5.5 million IOPS and steepening the performance curve that NVMe host controllers now have to feed (ServeTheHome, July 2026).

The Zynq UltraScale+ MPSoC is one of the most common targets for an FPGA-based NVMe controller: it pairs a hardened ARM processing system with programmable logic, high-speed GTH/GTY transceivers and an integrated PCIe block on a single device. That combination is exactly what an NVMe Host IP core — the kind covered in our complete guide to NVMe Host IP cores for FPGA — needs to drive an SSD directly, with no host CPU in the data path. This guide walks through the integration flow — how the pieces connect through PCIe, the GT transceivers and the AXI interconnect — so you can plan a Zynq UltraScale+ NVMe design with the right architecture from the start.

The short answer

On Zynq UltraScale+, an NVMe Host IP core lives in the programmable logic (PL) and acts as the PCIe root complex for one or more NVMe SSDs. It connects to the device’s integrated PCIe block, which in turn drives the GTH or GTY transceivers to the drive. Your application streams data to and from the core over AXI — typically AXI4-Stream for bulk data and AXI4-Lite for control — while the core handles the NVMe command set, queues and doorbells. The ARM processing system (PS) is optional in the data path: it can manage the core over an AXI-Lite link, or the design can run fully autonomously in the PL. The main integration work is wiring the core to the PCIe block, planning the transceiver and reference-clock resources, and closing timing on the AXI data path.

Why Zynq UltraScale+ suits an NVMe host

Zynq UltraScale+ suits an NVMe host because it puts the hardened PCIe block, the GTH/GTY transceivers and the ARM processing system on one die, so the whole storage path can be built and closed inside a single device. The processing system (PS) holds hardened ARM Cortex-A53 application cores and Cortex-R5 real-time cores, along with their peripherals. The programmable logic (PL) is the FPGA fabric where your custom datapath and IP cores live. For an NVMe host, three PL-side resources matter most:

  • The integrated PCIe block. Zynq UltraScale+ devices include a hardened PCIe controller in the PL, so the demanding PCIe physical and link layers run in silicon rather than consuming fabric. An NVMe Host core configures this block as a root complex.
  • GTH / GTY transceivers. These high-speed serial transceivers carry the PCIe lanes to the SSD. GTH transceivers cover the common PCIe generations; GTY transceivers, available on higher-speed device grades, reach the faster line rates. Which line rate you can hit is a PHY question — see Gen4 vs Gen5 NVMe Host IP on FPGA for what changes at the transceiver. Your device and speed grade decide which are available and how many lanes you can bring out.
  • AXI interconnect. The ARM AMBA AXI4 family is the native interface fabric across the device. It is how the NVMe core exchanges control, descriptors and bulk data with the rest of your design and, optionally, with the PS — our guide on connecting NVMe Host IP to your FPGA fabric over AXI covers that boundary in detail.

Because all of this sits on one device, a Zynq UltraScale+ NVMe design can be genuinely CPU-less in its data path: data moves from your source, through the PL, across PCIe to the SSD, without ever passing through an operating system. That is what makes the family a natural fit for recorders and high-speed data-acquisition systems that need deterministic, sustained write throughput.

How Zynq UltraScale+ compares with other FPGA families

Zynq UltraScale+ is the mid-range, integrated-SoC choice for an NVMe host: PCIe Gen3/Gen4 over GTH/GTY, with ARM cores on-die for the control plane. If you need Gen5 bandwidth or the lowest power, other families fit better. The table below places the device in the wider NVMe Host IP line-up so you can sanity-check your choice before committing to a part.

Where Zynq UltraScale+ sits among common NVMe Host IP targets
FPGA family Typical NVMe positioning Read next
AMD Zynq UltraScale+ MPSoC Integrated ARM SoC + PL; PCIe Gen3/Gen4 root complex over GTH/GTY. Balanced choice for recorders and storage controllers. This guide
Altera Agilex 7 (R-Tile) Highest bandwidth; hardened R-Tile for PCIe Gen5 NVMe. NVMe Host IP on Agilex 7 R-Tile
Microchip PolarFire SoC Low-power, RISC-V SoC path to NVMe for power- and thermally-constrained designs. NVMe Host IP on PolarFire SoC

Still choosing between interfaces rather than families? Read SATA vs NVMe for FPGA storage before you commit the datapath.

The integration architecture at a glance

The design is easiest to reason about as a stack of four layers with clean boundaries. In a typical Zynq UltraScale+ NVMe host, the SSD is a PCIe endpoint and the FPGA is the root complex that enumerates and drives it — the reverse of the more familiar case where the FPGA is an endpoint plugged into a server. LDS’s NVMe Host IP implements that root-complex host behaviour in the PL:

  • Application layer — your logic (a capture pipeline, a DMA engine, a processor) that produces or consumes data.
  • NVMe Host core — implements the NVMe protocol: admin and I/O queues, submission and completion queues, doorbell handling and data movement to and from the SSD.
  • Integrated PCIe block — the hardened root-complex controller handling the PCIe transaction, data-link and physical layers.
  • GTH / GTY transceivers — the serial lanes physically connecting to the SSD, typically over an M.2, U.2 or edge connector.

The value of this split is that each layer has a clean boundary. You integrate against the core’s AXI interfaces and let the core and the hardened PCIe block manage everything below them. The rest of this guide follows the order you would actually build the design.

Planning a Zynq UltraScale+ recorder or storage controller? A short design review of your device grade, lane plan and data path can save weeks of bring-up.

Talk to an FPGA engineer

Step-by-step integration

The following flow describes the generic integration sequence for an NVMe Host core on Zynq UltraScale+. Exact port names, parameters and resource figures depend on the specific core configuration and are covered in its deliverables.

  1. Confirm the device, speed grade and lane plan. Check that your Zynq UltraScale+ part exposes the PCIe generation and lane count you need, and that the required GTH or GTY transceiver quads are available and reachable on your board. This is a device-selection decision that is expensive to change later, so settle it first.
  2. Instantiate the integrated PCIe block as a root complex. Configure the hardened PCIe controller for root-complex operation at your target generation and lane width, and map it to the transceiver channels your board routes to the SSD connector.
  3. Place the NVMe Host core in the PL and connect it to the PCIe block. The core sits on top of the PCIe block and drives it. Wire the core’s PCIe-facing interface to the hardened controller so the core owns enumeration and the NVMe command flow.
  4. Provide the reference clock and derive the design clocks. Feed the transceivers their dedicated PCIe reference clock, and plan the AXI and user clock domains the core needs. Clocking is the single most common source of bring-up trouble, so treat it deliberately (see below).
  5. Connect the AXI interfaces. Attach the control interface (typically AXI4-Lite) to whatever configures the core — the PS or a state machine in the PL — and connect the data interface (typically AXI4-Stream, or memory-mapped AXI4 to a buffer) to your application datapath. If you want the full picture of that boundary, see our AXI-to-NVMe integration guide. If queues or buffers live in DDR, route those accesses through the appropriate high-performance ports.
  6. Decide the processing system’s role. Choose whether the PS runs software that manages the core (bare-metal or Linux) or whether the PL handles everything and the PS stays out of the data path. This choice shapes your control-plane wiring, not the high-speed datapath.
  7. Bring up the link and enumerate the SSD. Power the design, confirm the PCIe link trains to the expected width and generation, and verify the core enumerates the drive and initialises its NVMe queues. Link-training and enumeration issues almost always trace back to clocking, reset ordering or board signal integrity.
  8. Validate throughput and close timing. Exercise the datapath at rate, confirm the core sustains the write (or read) throughput your application needs, and close timing on the AXI paths. Measure sustained rate, not just burst rate — a recorder is defined by what it can hold continuously.

Interfaces and signals

An NVMe Host core exposes a small, well-defined set of interface groups — PCIe/transceiver, control, data, memory, clocks, reset and status. The table summarises the categories you will connect during integration; it describes interface types and their role, not the exact port list of any specific core.

Typical interface groups when integrating an NVMe Host core on Zynq UltraScale+
Interface group Typical type Role in the design
PCIe / transceiver Serial lanes via GTH/GTY + integrated PCIe block Physical path to the SSD; the hardened block handles the PCIe layers, the core drives it as root complex.
Control / register AXI4-Lite Configuration, status and command control of the core, driven by the PS or PL logic.
Data path AXI4-Stream or memory-mapped AXI4 Bulk read/write data between your application and the core; AXI4-Stream suits continuous capture flows.
Memory / descriptors AXI4 to DDR (via high-performance PS-PL ports) Optional access to buffers or queue structures held in external memory.
Clocks PCIe reference clock + AXI/user clocks Dedicated transceiver reference clock plus the core’s functional clock domains.
Reset Synchronous / asynchronous resets Ordered reset of the PCIe block, transceivers and core during bring-up.
Interrupt / status Level or pulse signals Completion and error signalling back to the control plane.

Clocking and reset

Clocking and reset ordering cause most NVMe bring-up failures on Zynq UltraScale+. The transceivers need a clean, correctly specified PCIe reference clock — usually sourced at the SSD connector — and getting its frequency, source or jitter wrong stops the link from training at all. Separately, the core operates in its own clock domains, so any crossing between your application clock and the core’s datapath clock must be handled with proper clock-domain-crossing logic; a missed CDC path shows up as intermittent, hard-to-reproduce data corruption.

Reset needs the same care. The integrated PCIe block, the transceivers and the core generally expect a defined reset sequence. Releasing them in the wrong order — or before their clocks are stable — leaves the link stuck. Plan the reset tree explicitly rather than assuming a single global reset will do the job.

Where the processing system fits

Keep the high-speed datapath in the PL and use the ARM PS only for the control plane. A frequent question on Zynq UltraScale+ is how much of the NVMe host should live in the ARM PS, and the honest answer is: as little as your application allows. The datapath belongs in the PL, where it stays deterministic. The PS is well suited to the control plane — initialising the core, handling configuration, responding to errors, and coordinating with the rest of a Linux or bare-metal system — but routing bulk storage data through the PS and its caches usually adds latency and jitter for no benefit.

Two workable patterns cover most designs. In the first, the PS runs software that configures and monitors the core over AXI4-Lite while the PL moves the data; this suits systems that already run Linux for other reasons. In the second, the PL handles everything autonomously and the PS does little or nothing in the storage path; this suits the most timing-critical recorders. Either way, keep the decision about the control plane separate from the datapath — they are independent choices.

Common integration pitfalls

Most Zynq UltraScale+ NVMe problems come from a short list of avoidable issues:

  • Choosing the device grade last. Transceiver type, lane count and PCIe generation are set by the part you pick. Deciding the datapath before confirming the device can force a redesign.
  • Underestimating the reference clock. A marginal or mis-specified PCIe reference clock is the classic reason a link will not train. Verify it against the PCIe requirements before blaming the logic.
  • Ignoring clock-domain crossings. Data corruption that appears only at rate is almost always a missed or mishandled CDC path between the application and the core.
  • Confusing burst and sustained throughput. An interface that bursts fast can still fall short over a continuous capture if the queues are starved. Validate the rate you must hold, not the peak.
  • Assuming the PS must be in the path. Routing bulk data through the ARM cores adds latency and jitter; keep the datapath in the PL unless you have a specific reason not to.

Need an NVMe host or storage IP core for your FPGA? Our engineers ship production-proven cores for AMD and Altera devices.

Talk to our IP team

Frequently asked questions

Does the NVMe Host core run in the PS or the PL on Zynq UltraScale+?

The core runs in the programmable logic (PL). The ARM processing system (PS) is optional and typically used only for the control plane — configuring and monitoring the core over AXI4-Lite. The high-speed data path stays in the PL to remain deterministic.

Is the FPGA the PCIe root complex or the endpoint?

For an NVMe host, the FPGA is the PCIe root complex and the SSD is the endpoint: the FPGA enumerates and drives the drive. This is the reverse of the case where an FPGA is an endpoint plugged into a host server.

Do I use GTH or GTY transceivers?

It depends on your device and speed grade. GTH transceivers cover the common PCIe generations; GTY transceivers, on higher-speed grades, reach the faster line rates. Confirm which are available on your chosen part and routed on your board before finalising the lane plan.

Which AXI interfaces does integration involve?

Typically AXI4-Lite for control and configuration of the core, and AXI4-Stream (or memory-mapped AXI4) for bulk data between your application and the core. If buffers or queues live in DDR, those accesses use the high-performance PS-PL ports.

What is the most common cause of link bring-up failure?

Clocking and reset. A mis-specified PCIe reference clock, or releasing the PCIe block, transceivers and core in the wrong reset order, will stop the link from training. Board signal integrity is the next thing to check.

Can a Zynq UltraScale+ NVMe design run without any processor in the data path?

Yes. The datapath can be fully contained in the PL, with the PS doing little or nothing in the storage path. That is a key reason the family suits deterministic recorders and data-acquisition systems.

What is the difference between Zynq UltraScale+ and Agilex 7 for an NVMe host?

Zynq UltraScale+ is an integrated ARM SoC that typically targets PCIe Gen3/Gen4 NVMe over GTH/GTY transceivers, well suited to recorders and storage controllers. Altera Agilex 7 with its hardened R-Tile targets the higher bandwidth of PCIe Gen5 NVMe. Choose Zynq UltraScale+ for an integrated SoC and Gen3/Gen4; choose Agilex 7 R-Tile when you need Gen5 bandwidth.

LDS
Logic Design Solutions
FPGA design house and soft-IP core vendor — NVMe, SATA, ARINC 429 and Ethernet IP for AMD and Altera FPGAs.

Integrating an NVMe Host core on Zynq UltraScale+? Tell us your device grade, lane plan and target throughput, and we will help you confirm the architecture before you commit.

License or request the IP

  1. AMD — Zynq UltraScale+ MPSoC (PS, PL, integrated PCIe and transceivers)
  2. NVM Express — NVMe specifications and queue model
  3. PCI-SIG — PCI Express base specification