握手型接口的同步FIFO实现

按照正常的思路，在前文完成前向时序优化和后向时序优化后，后面紧跟的应该是双向时序优化策略了，不过不急，需要先实现一下握手型同步FIFO。本章所述的FIFO具备以下的特性：

1.写入与读出均采用握手型接口；
2.支持2的整数次与非整数次深度；
3.FIFO写入数据至少一拍后才能读出，不能bypass；
4.输出逻辑为寄存器输出；

接口

握手型同步FIFO，接口如下：

module sync_fifo #(
	parameter DEPTH = 8,
	parameter WIDTH = 32
)(
    input 		clk,
    input 		rst_n,
	
    input  		in_valid,
    input  [WIDTH -1:0] in_data,
    output 		in_ready,
	
    output		out_valid,
    output [WIDTH -1:0] out_data,
    input  		out_ready
);

localparam DP_WD = $clog2(DEPTH);

endmodule

鉴于并非所有的工具和版本都能很好的支持$clog2函数，所以也可以将该函数展开来写。

根据通常的设计要求，对外输出的in_ready和out_valid最优为寄存器输出，以保证时序最优。out_data虽然理论上要作为寄存器输出，但是out_data可以接受有mux逻辑。不过这样在深度较浅时时序会比较好，深度太深mux逻辑带来的时序则不能忽略。

读写计数器

fifo采用传统的读写两个计数器模式，以写计数器为例进行说明，代码如下：

//==================================================================
//写入计数器
//==================================================================
reg  [DP_WD   :0]waddr;
wire             wenc;
wire             waddr_d_h;
wire [DP_WD -1:0]waddr_d_l;

assign wenc      = in_valid && in_ready;
assign waddr_d_h = (waddr[DP_WD-1:0] == DEPTH-1) ? ~waddr[DP_WD] : waddr[DP_WD];
assign waddr_d_l = (waddr[DP_WD-1:0] == DEPTH-1) ? {DP_WD{1'b0}} : waddr[DP_WD-1:0] + 1'b1;

always @(posedge clk or negedge rst_n)begin
	if(~rst_n)    waddr <= 0;
	else if(wenc) waddr <= {waddr_d_h, waddr_d_l};
end

地址指针waddr和raddr均比实际地址多一位，最高位用来指示套圈情况。当waddr和raddr的最高位相同时，fifo_cnt = waddr - raddr；当waddr和raddr的最高位相反时，fifo_cnt = DEPTH + waddr[ADDR_WIDTH-1:0] - raddr[ADDR_WIDTH-1:0]。

注意很多示意代码会让waddr一直累加翻转，这样的做法对于2^N深度的FIFO是没有问题的，而如果配置深度为非2^N深度则会出现跳转错误，因此在本代码中将addr区分为H和L两个区间，低位区间累加至DEPTH-1时高位区间翻转。

读出计数器的代码同样如此：

//==================================================================
//读出计数器
//==================================================================
reg  [DP_WD   :0]raddr;
wire             renc;
wire             raddr_d_h;
wire [DP_WD -1:0]raddr_d_l;
assign renc = out_valid && out_ready;
assign raddr_d_h = (raddr[DP_WD-1:0] == DEPTH-1) ? ~raddr[DP_WD] : raddr[DP_WD];
assign raddr_d_l = (raddr[DP_WD-1:0] == DEPTH-1) ? {DP_WD{1'b0}} : raddr[DP_WD-1:0] + 1'b1;
always @(posedge clk or negedge rst_n)begin
	if(~rst_n)    raddr <= 0;
	else if(renc) raddr <= {raddr_d_h, raddr_d_l};
end

深度计数器

通常FIFO的深度计数是通过waddr和raddr计算得到的，不过本文因为希望关键输出为寄存器输出需要用到fifo_cnt_d，因此做了一个深度计数器：

//==================================================================
//深度计数器
//==================================================================
reg  [DP_WD :0]fifo_cnt_q;

wire [DP_WD :0]waddr_d = wenc ? {waddr_d_h, waddr_d_l} : waddr;
wire [DP_WD :0]raddr_d = renc ? {raddr_d_h, raddr_d_l} : raddr;
wire [DP_WD :0]fifo_cnt_d = (waddr_d[DP_WD] == raddr_d[DP_WD]) ? (waddr_d[DP_WD-1:0] - raddr_d[DP_WD-1:0]):
															     (waddr_d[DP_WD-1:0] + DEPTH - raddr_d[DP_WD-1:0]);
wire fifo_cnt_en = (wenc ^ renc);
always @(posedge clk or negedge rst_n)begin
	if(~rst_n)    fifo_cnt_q <= 0;
	else if(fifo_cnt_en) fifo_cnt_q <= fifo_cnt_d;
end

数据寄存

数据寄存采用无复位寄存器以降低功耗，当然也可以使用sram实现，但是如果通过sram实现的话就需要考虑ram输出的多一拍延迟了，如果深度不是很深的话，建议直接通过寄存器实现吧。

//==================================================================
//数据寄存
//==================================================================
reg [WIDTH -1:0]data[DEPTH];
always @(posedge clk or negedge rst_n)begin
	if(wenc) data[waddr[DP_WD-1:0]] <= in_data;
end
assign out_data = data[raddr[DP_WD-1:0]];

对外逻辑

in_ready实际就是常用FIFO的full信号取反，out_valid就是empty的取反，因此单纯做逻辑是不难的。但是为了实现寄存器输出，最后选择了这样的逻辑：

//==================================================================
//对外逻辑
//==================================================================
//assign in_ready  = (fifo_cnt_q < DEPTH);
//assign out_valid = (fifo_cnt_q > {DP_WD{1'b0}});
wire in_ready_en;
wire in_ready_d;
reg  in_ready_q;
assign in_ready_en = (out_valid && out_ready) || in_ready;
assign in_ready_d  = (fifo_cnt_d < DEPTH);
always @(posedge clk or negedge rst_n)begin
	if(~rst_n)          in_ready_q <= 1;
	else if(in_ready_en)in_ready_q <= in_ready_d;
end

wire out_valid_en;
wire out_valid_d;
reg  out_valid_q;
assign out_valid_en = (in_valid && in_ready) || out_valid;
assign out_valid_d  = (fifo_cnt_d > {DP_WD{1'b0}});
always @(posedge clk or negedge rst_n)begin
	if(~rst_n)           out_valid_q <= 0;
	else if(out_valid_en)out_valid_q <= out_valid_d;
end

assign in_ready  = in_ready_q;
assign out_valid = out_valid_q;

好的所有代码就是这些，auto_testbench的结果：