`timescale 1ns/1ps // Portable dual-clock FIFO. RAM words cross domains only through a clocked // read port; Gray pointers cross through independent two-stage synchronizers. // Reset is shared by both domains. The output register adds one holding slot // beyond the 2**ADDR_BITS RAM locations after the read clock starts. module async_sample_fifo #( parameter integer WIDTH = 96, parameter integer ADDR_BITS = 9 ) ( input wire arst_n, input wire wr_clk, input wire wr_valid, input wire [WIDTH-1:0] wr_data, output wire wr_ready, output reg wr_overflow, output reg wr_overflow_sticky, output reg [31:0] wr_overflow_count, input wire rd_clk, output wire rd_valid, output reg [WIDTH-1:0] rd_data, input wire rd_ready ); localparam integer POINTER_BITS = ADDR_BITS + 1; localparam integer DEPTH = 1 << ADDR_BITS; wire wr_rst, rd_rst; reset_sync wr_reset (.clk(wr_clk), .arst_n(arst_n), .rst(wr_rst)); reset_sync rd_reset (.clk(rd_clk), .arst_n(arst_n), .rst(rd_rst)); (* ram_style = "block" *) reg [WIDTH-1:0] ram [0:DEPTH-1]; reg [POINTER_BITS-1:0] wr_binary, wr_gray; reg [POINTER_BITS-1:0] rd_binary, rd_gray; (* ASYNC_REG = "TRUE", SHREG_EXTRACT = "NO" *) reg [POINTER_BITS-1:0] rd_gray_w1, rd_gray_w2; (* ASYNC_REG = "TRUE", SHREG_EXTRACT = "NO" *) reg [POINTER_BITS-1:0] wr_gray_r1, wr_gray_r2; reg wr_full, rd_empty, output_valid; assign wr_ready = arst_n && !wr_rst && !wr_full; assign rd_valid = arst_n && !rd_rst && output_valid; wire wr_accept = wr_valid && wr_ready; wire rd_fetch = !rd_rst && arst_n && (!output_valid || rd_ready) && !rd_empty; wire [POINTER_BITS-1:0] wr_binary_next = wr_binary + wr_accept; wire [POINTER_BITS-1:0] rd_binary_next = rd_binary + rd_fetch; wire [POINTER_BITS-1:0] wr_gray_next = (wr_binary_next >> 1) ^ wr_binary_next; wire [POINTER_BITS-1:0] rd_gray_next = (rd_binary_next >> 1) ^ rd_binary_next; wire wr_full_next = wr_gray_next == {~rd_gray_w2[ADDR_BITS:ADDR_BITS-1], rd_gray_w2[ADDR_BITS-2:0]}; wire rd_empty_next = rd_gray_next == wr_gray_r2; initial begin if (WIDTH < 1 || ADDR_BITS < 2) $error("async_sample_fifo requires WIDTH >= 1 and ADDR_BITS >= 2"); end // No RAM/output-data reset: the valid flags own initialized state, and // keeping these ports clocked without reset permits dual-port BRAM inference. always @(posedge wr_clk) if (wr_accept) ram[wr_binary[ADDR_BITS-1:0]] <= wr_data; always @(posedge rd_clk) if (rd_fetch) rd_data <= ram[rd_binary[ADDR_BITS-1:0]]; always @(posedge wr_clk or posedge wr_rst) begin if (wr_rst) begin rd_gray_w1 <= 0; rd_gray_w2 <= 0; end else begin rd_gray_w1 <= rd_gray; rd_gray_w2 <= rd_gray_w1; end end always @(posedge rd_clk or posedge rd_rst) begin if (rd_rst) begin wr_gray_r1 <= 0; wr_gray_r2 <= 0; end else begin wr_gray_r1 <= wr_gray; wr_gray_r2 <= wr_gray_r1; end end always @(posedge wr_clk or posedge wr_rst) begin if (wr_rst) begin wr_binary <= 0; wr_gray <= 0; wr_full <= 0; wr_overflow <= 0; wr_overflow_sticky <= 0; wr_overflow_count <= 0; end else begin wr_binary <= wr_binary_next; wr_gray <= wr_gray_next; wr_full <= wr_full_next; wr_overflow <= wr_valid && !wr_ready; if (wr_valid && !wr_ready) begin wr_overflow_sticky <= 1'b1; if (wr_overflow_count != 32'hffffffff) wr_overflow_count <= wr_overflow_count + 1'b1; end end end always @(posedge rd_clk or posedge rd_rst) begin if (rd_rst) begin rd_binary <= 0; rd_gray <= 0; rd_empty <= 1; output_valid <= 0; end else begin rd_binary <= rd_binary_next; rd_gray <= rd_gray_next; rd_empty <= rd_empty_next; if (!output_valid || rd_ready) output_valid <= rd_fetch; end end endmodule