Integrating an exFAT IP for FPGA Storage

Integrating an exFAT IP for FPGA Storage

An ExFAT IP core belongs alongside the NVMe host IP, but block names alone do not define the integration boundary. We recommend assigning ownership for file-operation decisions, storage-command choices, configuration, and error handling before finalizing the connection.

The short answer

We recommend placing the ExFAT IP core alongside the NVMe host IP, using a distinct handoff whose ownership follows the design’s assigned responsibilities.

For the design’s handoff, define which side owns each file-operation decision, which side selects the storage read or write command, and what information crosses the boundary, then record configuration and error-handling ownership in the same integration notes as the diagram. Treat these as design assignments, not assumed features of either IP core. Leave unresolved responsibilities open before finalizing the connection.

Where should the ExFAT IP core sit alongside the NVMe host IP?

We recommend showing the ExFAT IP core alongside the NVMe host IP, with a distinct interface between them; let your design’s assigned responsibilities, not the block names alone, determine the boundary.

Start with ownership. Before fixing the connection, write down what the design assigns to each block, what information should cross the boundary, and which block owns configuration and error handling, so the diagram records deliberate interface decisions rather than assumptions based on labels.

For the design review, make the boundary match the responsibilities your design assigns. Record the expected inputs and outputs, configuration points, and error-handling responsibilities for your implementation. Keep those details specific to the design rather than treating them as built-in features of either IP core. If a responsibility has no clear owner in the draft, resolve that assignment before finalizing the connection.

Use the same boundary in the architecture diagram and integration notes, and name the handoff in terms your team can use. Describe what each side is expected to provide or accept, then use consistent names for those items across the diagram and requirements. This gives reviewers a concrete way to discuss the intended split without assuming details from the IP names.

How should file operations and storage transactions be divided across the FPGA design?

We recommend assigning file-operation decisions to the ExFAT side and storage read/write I/O command selection to the NVMe side, whose NVM Command Set specification defines read and write I/O commands.

Keep file-operation intent distinct from storage-command choice. In a design note, name the file operation first, then state whether the storage transaction uses a read or write command. Keep each decision’s owner visible rather than leaving it implicit in a block diagram.

For example, describe a read case by recording the file-side operation and identifying read as the storage command; use the same format for a write case. These are documentation examples, not claims about a particular interface or implementation. The cited specification establishes the read and write command categories, while your design defines how responsibilities are assigned between the IP blocks.

Keep the boundary explicit. A useful review checklist is:

  • File operation: name the operation assigned to the ExFAT side.
  • Storage command: identify read or write on the NVMe side.
  • Decision owner: record which side owns each choice.

Use this checklist to discuss each operation without implying an implementation detail that has not been decided. If a design choice is still open, mark it as open instead of letting the responsibility split appear to settle it. This keeps review comments tied to a named operation and its proposed storage command, rather than to an unstated assumption about how the two IP blocks connect.

Is exFAT just FAT32?

No. exFAT retains some basic FAT32 concepts but introduces differences, including a new directory-entry mapping scheme, so it is not simply FAT32 under another name, as a published analysis of exFAT explains.

That is not a naming detail. For an FPGA requirements document, specify exFAT explicitly rather than treating a FAT32 description as interchangeable. The cited mapping difference gives one concrete reason to keep the filesystem choice visible: record directory-entry mapping as a requirement to address, not as an assumed match. Our recommendation is to state the selected filesystem and the required file-size ceiling explicitly in the design specification.

Microsoft’s filesystem functionality comparison compares maximum file sizes for exFAT and FAT32 and marks exFAT as lacking metadata-only journaling.

Feature exFAT FAT32
Maximum file size 264−1 bytes 4 GiB

The size values offer a direct decision point: if the application must accommodate a file larger than FAT32’s listed maximum, the exFAT maximum in the comparison is the relevant value. Keep the required ceiling explicit instead of reducing both formats to a shared “FAT” label.

Keep metadata-only journaling separate from the file-size requirement. The comparison marks exFAT as lacking that feature; record it as its own criterion rather than treating the file-size row as an answer to it. The published analysis also identifies the directory-entry mapping scheme as a difference, so make that an explicit compatibility question when specifying the core.

Are exFAT and Ext4 the same?

The cited documentation cannot establish whether exFAT and Ext4 are the same; it says that “the ext4 filesystem employs a journal to protect the filesystem against metadata inconsistencies in the case of a system crash.”

Keep that boundary clear.

For an FPGA design, turn the comparison into a requirements question before treating either filesystem name as a design decision. Identify which filesystem the project must support, then list the behaviors the implementation is required to provide. Mark a behavior as established only when a source documents it for the relevant filesystem; leave the exFAT side unresolved where supporting evidence is absent.

Our recommendation: do not treat the Ext4 journal statement as evidence of exFAT behavior. If protection against metadata inconsistencies after a system crash is a project requirement, record the Ext4 property in the terms used by the documentation and link it to the Linux kernel’s Ext4 journal documentation. That keeps the claim within its stated scope instead of extending it to another filesystem.

When evaluating an ExFAT IP core, keep the filesystem requirement, the IP implementation requirements, and their evidence in separate entries in the design review. For each required behavior, note which filesystem it concerns and attach the source that supports the claim. If a requirement has no source for exFAT, mark it as an open question rather than assuming it matches the Ext4 property. This gives the design team a clear basis for deciding what still needs technical documentation before the comparison can be resolved.

How should an on-site data recorder shape the ExFAT and NVMe integration?

Our recommendation: shape ExFAT and NVMe integration around the recorder’s own acceptance criteria, testing write ordering and power-interruption behavior and reporting only the cases run.

Keep that test result distinct from evidence that a particular ExFAT and NVMe configuration has passed recorder-specific power-interruption tests.

Keep the matrix compact.

  • Choose a write sequence that matches the recorder’s intended operation, with one interruption point per case.
  • Set the expected result before running each case, using the recorder’s requirements as the acceptance criteria.
  • Record the test setup, design revision, interruption point, expected result, observed result, and pass or fail decision together.
  • Use separate cases for different interruption points instead of combining them into one overall result.

Keep the conclusion narrow: report which case ran and whether it met its stated criterion. A passing result for one case does not establish a result for cases the test did not cover, so report each outcome within the scope of its test.

Which cluster and allocation requirements should the design specify?

Specify the supported cluster-size range: the exFAT specification sets the lower limit at one sector and the upper limit at 32 MB.

For an ExFAT IP core, turn that format boundary into an explicit implementation requirement. We recommend separating the specification’s limits from the cluster sizes the design commits to supporting, because the stated limits are not, by themselves, a commitment that every size within them is supported by your implementation.

Keep the contract explicit. In the design requirements, record:

  • Which cluster sizes the implementation supports.
  • Whether the selected cluster size is fixed or configurable.
  • Where that selection is made, and which design component owns it.
  • How the design handles a requested size that is not in its supported set.

Use precise units when documenting the supported range, and state whether each supported value is expressed in sectors or megabytes. Avoid describing the IP simply as “exFAT compatible” when the allocation requirement needs a specific cluster-size commitment; a precise supported-size list gives the integration team a concrete configuration contract.

Keep the requirement and its acceptance criteria aligned. For each supported configuration, state the expected selected size and define how the design will indicate that the configuration is unsupported. If the cluster-size choice is fixed, record that constraint in the integration documentation; if it is configurable, specify the permitted choices and where the selection is supplied. These are design decisions to make explicit, not assumptions to leave for integration.

What should an ExFAT IP demonstration verify before integration?

Before integration, we recommend checking the demonstration’s sector size against the exFAT specification and requiring a meaningful, repeatable filesystem test with written pass/fail criteria. The Linux kernel’s filesystem guidance says a filesystem must be testable in a meaningful way.

Keep the checks separate. Record the sector size used by the demonstration and compare it with the exFAT specification’s stated range of 512 to 4,096 bytes. Keep the two results separate; do not collapse them into a single “demo passed” label.

For the filesystem test, write down the procedure before running it. Name the condition being evaluated, the expected outcome, and the rule for pass or fail. The kernel guidance on meaningful filesystem testing sets the testability criterion; a repeatable procedure and an explicit result are a practical way to apply it in an integration review.

Before the run, write down the configuration being checked, the operation or condition under test, the expected result, and the pass/fail rule; then repeat the same procedure and record the outcome against those criteria.

Keep the record tied to the demonstration under review. Include the configured sector size, the rule used for the range check, the test description, the expected outcome, and the result. A reviewer should be able to trace each status to a written criterion. If a result cannot be classified from that criterion, refine it and rerun the test rather than treating an unclear result as a pass.

Treat the specification as product-level context; base this checkpoint on evidence recorded for the ExFAT IP demonstration itself.

Make the acceptance decision explicit: sector-size compatibility, meaningful filesystem testing, repeatability, and the recorded outcome. Use the individual checks, not an overall demo label, as the basis for that decision.

When does a different storage interface or custom FPGA development fit better?

Choose a different storage interface when the application boundary does not fit the filesystem approach under review; choose custom FPGA development only for a defined requirement those options do not address.

For an ExFAT IP core, use the application boundary as the comparison point. SNIA’s key-value storage Q&A states: “In order to take advantage of Key Value storage, the application itself may need to change, depending on what the current application interface is.” Include application changes in the interface decision, rather than treating storage implementation as the only question.

Option to assess Decision prompt
Filesystem interface Does the specified application boundary fit the filesystem approach under review?
Key-value interface What application-interface changes might be needed, given the current interface?
Custom FPGA development Which defined requirement do the options under review not address?

First, keep the boundary explicit. List the requirements the design must preserve. For each candidate, record which assumptions can remain and which need reconsideration, so the cost of an interface change remains part of the decision rather than being separated from the application’s requirements.

Our recommendation: keep the filesystem path in consideration when it matches the requirements on your list. Include possible application changes in the scope of a key-value path. Choose custom FPGA development when a specific requirement remains outside the options under review; without that requirement, the route has no clear decision basis. For every option, compare against the same requirements, not the interface label alone.

Keep unresolved boundary questions visible before settling on an implementation. When the application changes for a key-value option are unclear, record that as an open decision item; uncertainty alone does not show that the option is unsuitable.

Frequently asked questions

Is exFAT just FAT32?

No. The article explains that exFAT is not simply FAT32 under another name: it uses a different directory-entry mapping scheme, and Microsoft’s filesystem functionality comparison lists different maximum file sizes for the two formats.

Is exFAT easily corrupted?

The article does not establish that exFAT is easily corrupted. It notes that Microsoft’s filesystem functionality comparison lists exFAT as lacking metadata-only journaling, but that does not establish how often corruption occurs or how likely it is.

In summary

Before closing the architecture, record the file-operation owner and storage-command owner at each handoff. Keep the inputs, outputs, configuration, and error-handling assignments consistent between the diagram and integration notes. Mark unresolved choices as open, then use them to focus the design review. Keep each requirement specific to your implementation rather than treating filesystem or IP names as proof of behavior.

How we wrote this article

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. NVM Command Set Specification – NVM Express, nvmexpress.org
  2. [1804.08653] Forensic Analysis of the exFAT artefacts, arxiv.org
  3. File System Functionality Comparison – Win32 apps | Microsoft Learn, learn.microsoft.com
  4. 3.6. Journal (jbd2): The Linux Kernel documentation, kernel.org
  5. Linux-Kernel Archive: [PATCH v3] exfat: do not clear VolumeDirty in writeback, lkml.rescloud.iu.edu
  6. exFAT File System Specification – Win32 apps | Microsoft Learn, learn.microsoft.com
  7. NVMe Key-Value Standard Q&A | SNIA | Experts on Data, snia.org
  8. Products – Logic Design Solutions | Logic Design Solutions, logic-design-solutions.com
  9. Adding New Filesystems: The Linux Kernel documentation, docs.kernel.org