Educational Website

FBI + NPHY: From SSD Package to Digital RTL Modules

This page descends layer-by-layer from visible SSD hardware into NAND interface architecture, then ends with digital block and module-level design code.

FBI = Frequency Boosting Interface NPHY = NAND PHY Interface Focus: Digital logic (DMA/FIFO/BCH/Control)
Current Level: L0 · FBI + NAND Intro

First Screen: FBI + NAND Picture Context

FBI-chip and NAND architecture figure from IMAPS paper

FBI-chip concept + NAND loading reduction (IMAPS reference figure page).

What this image means

This figure shows why FBI exists: the FBI chip is inserted near NAND to reduce capacitive loading, improve timing margin, and stabilize high-speed internal I/O in stacked NAND packages.

Definition: FBI (Frequency Boosting Interface) is a digital retiming/control assist block between controller and NAND-side signaling paths.

Samsung 990 PRO SSD exterior

Example SSD exterior used as the top-level product view.

Why NAND is shown with SSD first

Users start at product level (SSD module), then descend to controller/NAND interfaces. This follows your document hierarchy exactly.

Definition: NAND is non-volatile storage media; NPHY and FBI are used to move data safely and quickly between NAND and the SSD controller.

SSD Exterior to Internal Package

SSD front view

Exterior: user-visible SSD module (M.2 form factor).

Definition

At this layer, we only identify major packaged components. Functional internals are not visible yet.

Goal: descend from package-level understanding into controller/NAND interaction details.

SSD internal components PM9E1-like image

Interior view: NAND dies + DRAM + Controller in one board-level assembly.

What to look for next

The critical block for protocol and timing behavior is the Controller. We descend into controller internals first, then isolate NPHY and FBI-related blocks.

Controller Focus (Clickable)

PM9E1 style internal board with controller Controller (Click)

Only controller is emphasized for deep-dive, as required in your source text.

Why controller-only click

Your document asks to skip unrelated parts and make the controller the main interactive entry.

Controller includes command engine, DMA/FIFO data path, ECC logic, and PHY bridge points.

Controller IP Block Diagram

Controller IP for NAND flash architecture NPHY / PHY edge (Click)

From command/data/ECC flow to PHY boundary.

Block definitions

  • Command Engine: decodes host/NAND operations and orchestrates flow.
  • DMA + FIFO: moves data with buffering across clock domains.
  • BCH Engine: error-correction for NAND reliability.
  • NPHY boundary: timing/interface block before NAND devices.

NPHY (NAND PHY) Detail

ONFi PHY architecture between flash IP and NAND flash

ONFi PHY style architecture: PHY_RX/PHY_TX and Flash I/O interface blocks.

Definition and role

NPHY is the physical interface protocol logic between NAND and SSD controller-side logic. It localizes timing-sensitive transactions near NAND.

This site intentionally focuses on digital design visibility (state control, FIFO/DMA orchestration, and command/data framing), not analog circuit internals.

FBI Placement Between Controller and NAND

Simplified path from SoC logic to NAND PHY and NAND device

Baseline path: SoC side logic -> NAND PHY -> NAND device.

FBI insertion concept

FBI can be modeled as a digital assist layer near NAND-side routing: status decision logic + retiming control to improve margin at higher interface speed.

Practical effect: less skew sensitivity and stronger timing closure under multi-die loading.

Controller NPHY FBI Retiming + Status NAND Package

Conceptual digital block flow after FBI insertion.

Final Layer: Digital Modules + RTL-Style Code

End-point view requested in your document: module and block-level hardware design code with clear definitions beside each module.

Module A: NPHY Command FIFO Path

module nphy_cmd_path (
  input  logic        clk,
  input  logic        rst_n,
  input  logic [63:0] host_cmd,
  input  logic        host_cmd_v,
  output logic        host_cmd_r,
  output logic [63:0] phy_cmd,
  output logic        phy_cmd_v,
  input  logic        phy_cmd_r
);
  logic [63:0] cmd_fifo_dout;
  logic        cmd_fifo_empty;

  async_fifo #(.WIDTH(64), .DEPTH(16)) u_cmd_fifo (
    .wclk(clk), .wrst_n(rst_n), .wvalid(host_cmd_v), .wready(host_cmd_r), .wdata(host_cmd),
    .rclk(clk), .rrst_n(rst_n), .rvalid(!cmd_fifo_empty), .rready(phy_cmd_r), .rdata(cmd_fifo_dout)
  );

  assign phy_cmd   = cmd_fifo_dout;
  assign phy_cmd_v = !cmd_fifo_empty;
endmodule

Definition: Buffers and forwards host/controller command traffic into the NPHY-facing command stream using FIFO-safe flow control.

Module B: FBI Retiming Controller

module fbi_retimer_ctrl (
  input  logic       clk,
  input  logic       rst_n,
  input  logic [7:0] skew_metric,
  input  logic       training_req,
  output logic [2:0] dq_delay_sel,
  output logic       retrain_done
);
  typedef enum logic [1:0] {IDLE, TRAIN, LOCK} state_t;
  state_t state;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      state <= IDLE;
      dq_delay_sel <= 3'd0;
      retrain_done <= 1'b0;
    end else begin
      case (state)
        IDLE:  if (training_req) state <= TRAIN;
        TRAIN: begin
          dq_delay_sel <= skew_metric[7:5];
          state <= LOCK;
        end
        LOCK: begin
          retrain_done <= 1'b1;
          if (training_req) state <= TRAIN;
        end
      endcase
    end
  end
endmodule

Definition: Digital FBI control FSM for selecting retiming delay based on measured skew/timing status.

Module C: DMA + ECC Data Plane

module nand_data_plane (
  input  logic         clk,
  input  logic         rst_n,
  input  logic [255:0] dma_in_data,
  input  logic         dma_in_v,
  output logic         dma_in_r,
  output logic [255:0] nand_wr_data,
  output logic         nand_wr_v,
  input  logic         nand_wr_r
);
  logic [255:0] ecc_data;
  logic         ecc_v;

  bch_encode u_bch (
    .clk(clk), .rst_n(rst_n),
    .in_data(dma_in_data), .in_valid(dma_in_v), .in_ready(dma_in_r),
    .out_data(ecc_data), .out_valid(ecc_v), .out_ready(nand_wr_r)
  );

  assign nand_wr_data = ecc_data;
  assign nand_wr_v    = ecc_v;
endmodule

Definition: A digital path combining DMA payload movement and ECC preparation before data reaches NAND write pipelines.