116 lines
4.2 KiB
Systemverilog
116 lines
4.2 KiB
Systemverilog
`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
|