Multi vendor NVMe and SATA IP integration on FPGA

Multi vendor NVMe and SATA IP integration on FPGA

When NVMe and SATA must coexist on an FPGA, we recommend defining the required functions and the boundary each core must meet before comparing candidates. A shared system-facing contract keeps the comparison focused on the design’s needs, while a separate mapping records each vendor-specific implementation.

The short answer

We recommend combining NVMe and SATA on an FPGA only when the system needs both.

Keep two decisions separate. Does the system need both protocols? Does a particular core fit the target design?

Define the function required from each protocol and the interface each core must present to the surrounding design. Then compare candidates against one shared, vendor-neutral contract, keeping implementation assumptions and unanswered questions separate; a protocol label identifies the function under consideration, but does not by itself settle FPGA architecture or implementation-tool questions.

Which NVMe and SATA functions need to coexist on the FPGA?

We recommend putting both protocols on the FPGA only when the system requirements call for both. Define the functions and integration boundary first, so the core comparison addresses the design rather than an assumed need for feature coverage.

The NVMe base specification describes its interface for SSDs as lower-latency and more scalable than legacy interfaces such as SATA. We would use that comparison to frame the system requirement, not as a prediction of the performance of a particular FPGA implementation.

Before evaluating cores, record four answers:

  • Does the design require NVMe, SATA, or both?
  • Which functions must the FPGA implement?
  • Where does each core connect to the surrounding design?
  • Which functions are outside the FPGA’s scope?

Keep the answers tied to the intended system: if only one protocol is required, leaving the other out of the FPGA scope keeps the comparison centered on the actual design need; if both are required, give each core the same clearly defined interface boundary before considering vendor-specific mappings.

For teams evaluating reusable FPGA logic, Logic Design Solutions presents its product offering as FPGA IP cores. For a project that needs development beyond core selection, the company says a custom FPGA development engagement can run from specification and architecture through RTL, integration, verification, and timing closure to a validated bitstream.

How should cores be compared across vendor boundaries?

We recommend comparing vendor cores against one shared interface contract, with vendor-specific assumptions recorded separately. The SHA-3 evaluation paper describes a harness specifying candidate-module interfaces; we use it as a method precedent, not evidence about NVMe or SATA cores.

Before scoring candidates, write down the boundary being compared and the information each candidate must map to it. Keep the same criteria and terms for every candidate. That lets the team distinguish a shared requirement from a vendor-specific qualification, instead of allowing one implementation’s terminology to redefine the baseline.

We recommend structuring the review around four items:

  • The interface boundary: describe the system-facing expectations in terms that apply to every candidate.
  • The available evidence: record what each candidate documents at that boundary, leaving unsupported details open.
  • Vendor-specific assumptions: keep qualifications and mappings alongside, but separate from, the shared criteria.
  • The decision status: distinguish required criteria from preferences, and mark unresolved points rather than treating them as confirmed.

This approach standardizes the questions, not the answers. We recommend keeping the comparison narrow enough that each criterion connects to a requirement in the design brief. That makes the eventual choice easier to explain without implying that every vendor documents its core in the same way.

Which interface contracts should remain stable across vendors?

We recommend keeping the system-facing contract vendor-neutral and documenting each core’s mapping to it separately. The contract should capture the expectations the surrounding design relies on, rather than the internal organization of one implementation.

Start at the boundary between the core and the surrounding logic. We recommend defining what each signal means, what the receiving logic is expected to provide, and how the design represents reset, configuration, status, and errors. Keeping these expectations in one shared description gives the comparison a consistent reference point.

Accellera’s IP-XACT specification describes a standard for IP metadata, design flows, and the interconnection of IP interfaces. We would use that stated scope when documenting those items, while writing behavioral expectations for the system explicitly rather than assuming metadata covers every requirement.

For each implementation, we recommend recording how its signals or fields map to the shared expectations and what translation the integration requires; if a core uses a different name or representation, keep that difference in its mapping instead of incorporating it silently into the common definition. Mark an expectation as not applicable where appropriate. That way, an empty entry does not leave its meaning ambiguous.

Keep the contract reviewable before integration depends on it. We recommend defining terms such as request, completion, status, and error where they first appear, then recording decisions in one place. Link each vendor-specific mapping to that record, so a change to one implementation can be assessed against the same stated expectations.

A technician probes a programmable logic board connected to two storage devices during a bench test.

How should verification cover interactions between cores?

We recommend covering core interactions in layers: exercise interfaces with bus-functional models, check transactions in self-checking testbenches, then move from directed cases to constrained-random generation, following the book description’s 3 verification transitions (book description of verification transitions).

Start at the boundary. For each interaction in scope, list the interface inputs and outputs the test will exercise, identify the transaction that drives them, and write the expected result beside the check that decides whether it matches, rather than leaving behavior implicit in the stimulus.

Use a bus-functional model for interface-level work, then move to a self-checking testbench at the transaction level. Keep the roles clear: specify which inputs and outputs are in scope, then make the expected transaction result explicit in the check. Keep those decisions visible in the test plan.

For interactions that need a fixed scenario, write a directed case that states its stimulus, expected outcome, and mismatch condition. That gives the case a clear purpose. Then use constrained-random generation to explore combinations beyond those named cases, with constraints tied to the design’s specified inputs and behavior. When a generated scenario fails, preserve it in a form that can become a directed case.

Let constrained-random generation explore combinations, but keep expected behavior explicit in the checker. Randomized stimulus does not replace that definition. End by reviewing coverage against required interactions: note which have directed cases, which are covered by generated tests, and which remain open. Use system requirements to set pass criteria, and do not treat a broad set of transactions as proof that the particular core boundaries have been checked.

How should FPGA-specific constraints shape core selection?

We recommend assessing each core against the target FPGA architecture and synthesis and back-end layout tools, rather than treating protocol support as proof of implementation fit.

FPGA and ASIC design flows are similar, but limitations inherent in FPGA devices also create differences, according to this FPGA design-flow abstract.

Electronic Design’s article on HDL coding in LUT-based FPGAs says that obtaining optimal results requires understanding the FPGA architecture, synthesis tool, and back-end layout software, and we recommend making those design-context inputs explicit in the selection record for every candidate.

  • Name the target FPGA architecture.
  • Record the synthesis tool and back-end layout software in scope.
  • Mark unanswered fit questions as unresolved instead of treating them as confirmed.

Keep protocol coverage separate from implementation fit. We recommend assessing what function a core addresses independently from whether the target architecture and tools have been accounted for. If those design inputs change, revisit the selection against the revised context rather than carrying an earlier assumption forward.

When is an FPGA-centered design the wrong endpoint?

We recommend evaluating an ASIC when production volume is high; a Technical University of Denmark thesis says high setup and design costs make ASICs economically viable only at high volumes (Performance aspects of synthesizable computing systems).

Use that finding as a reason to evaluate the alternatives, not as an automatic switch rule. We recommend putting the expected production volume, setup costs, and design costs into the decision brief, then comparing the FPGA-centered and ASIC options against the same project assumptions.

Keep the endpoint decision separate from the core-integration decision. A design may need an FPGA-based implementation while the team is still assessing whether that should remain the final architecture. We recommend making that choice deliberately, based on the project’s production and cost assumptions, instead of letting the integration path settle it by default.

In summary

We recommend defining the system-facing contract before comparing candidates. Record the target architecture and tools, map each core to the same boundary, and keep vendor-specific assumptions and unresolved points visible. Then build verification around the cross-core interactions the system requires. If both protocols are not needed, leave one outside the FPGA scope.

How we wrote this article

The sources we consulted are listed at the end of the article, consulted on 3 November 2026. Where we cite none, it is our opinion, and we write it as such.

This article gives buying criteria and our point of view. It does not replace a professional’s advice on a specific situation.

It is published by Logic Design Solutions, which therefore has an interest in the subject.

Sources
  1. Writing Testbenches using SystemVerilog by Bergeron, Janick, fpgarelated.com
  2. Performance driven FPGA design with an ASIC perspective, fpgarelated.com
  3. Careful HDL Coding Maximizes Performance In LUT-Based FPGAs | Electronic Design, electronicdesign.com
  4. NVM Express® Base Specification – NVM Express, nvmexpress.org
  5. Fair and Consistent Hardware Evaluation of Fourteen Round Two SHA-3 Candidates | Shin’ichiro Matsuo@Georgetown, people.cs.georgetown.edu
  6. Download IP-XACT – Accellera Systems Initiative, accellera.org
  7. Products – Logic Design Solutions | Logic Design Solutions, logic-design-solutions.com
  8. FPGA Design Services: What an IP-Focused Design House Delivers – Logic Design Solutions | Logic Design Solutions, logic-design-solutions.com
  9. Performance Aspects of Synthesizable Computing Systems – Welcome to DTU Research Database, orbit.dtu.dk