前言
关于FIFO和异步处理我已经写过很多东西了：
【异步FIFO的一些小事·2】异步FIFO中异步走线延时约束的一些思考
【异步FIFO的一些小事·3】异步FIFO中指针走线延时的一些思考
这次因为保持代码手感的需要，重新写一次异步fifo。写的过程突然感觉自己成长了许多，毕业时候抠抠索索的照着教程写了好几天，到今天心里合了一下时序一个多小时就手撕代码完成，看来这几年班不是白上的啊~
整体结构
整体的思路很常规，模块分为四个部分：写通路控制、读通路控制、异步单元、双口RAM。
写通路控制：负责产生ram写地址和写有效，产生wfull信号；
读通路控制：负责产生ram读地址和读有效，产生rempty信号；
异步单元：负责地址指针的跨异步处理；
双口RAM：负责存储数据；
整体结构图如下：
顶层如下：
module asyn_fifo#(
parameter WIDTH = 8,
parameter DEPTH = 16
)(
input wclk ,
input rclk ,
input wrstn ,
input rrstn ,
input winc ,
input rinc ,
input [WIDTH-1:0] wdata ,
output wire wfull ,
output wire rempty ,
output wire [WIDTH-1:0] rdata
);
//===================================
//写通路控制模块
//===================================
wire [$clog2(DEPTH) :0]raddr_sync;
wire wenc;
wire [$clog2(DEPTH) :0]waddr;
wctrl_path #(
.DEPTH(DEPTH))
u_wctrl_path(
.wclk(wclk),
.wrstn(wrstn),
.winc(winc),
.raddr_sync(raddr_sync),
.wenc(wenc),
.waddr(waddr),
.wfull(wfull)
);
//===================================
//读通路控制模块
//===================================
wire [$clog2(DEPTH) :0]waddr_sync;
wire renc;
wire [$clog2(DEPTH) :0]raddr;
rctrl_path #(
.DEPTH(DEPTH))
u_rctrl_path(
.rclk(rclk),
.rrstn(rrstn),
.rinc(rinc),
.waddr_sync(waddr_sync),
.renc(renc),
.raddr(raddr),
.rempty(rempty)
);
//===================================
//ram控制
//===================================
dual_port_RAM #(
.DEPTH(DEPTH),
.WIDTH(WIDTH))
u_dual_port_RAM(
.wclk(wclk),
.wenc(wenc),
.waddr(waddr[$clog2(DEPTH)-1:0]),
.wdata(wdata),
.rclk(rclk),
.renc(renc),
.raddr(raddr[$clog2(DEPTH)-1:0]),
.rdata(rdata)
);
//===================================
//写跨异步
//===================================
gary_sync_cell#(
.WIDTH($clog2(DEPTH)+1),
.SYNC_CYC(3))
u_wgary_sync_cell(
.in_clk(wclk),
.in_rst_n(wrstn),
.out_clk(rclk),
.out_rst_n(rrstn),
.in_data(waddr),
.out_data(waddr_sync)
);
//===================================
//读跨异步
//===================================
gary_sync_cell#(
.WIDTH($clog2(DEPTH)+1),
.SYNC_CYC(3))
u_rgary_sync_cell(
.in_clk(rclk),
.in_rst_n(rrstn),
.out_clk(wclk),
.out_rst_n(wrstn),
.in_data(raddr),
.out_data(raddr_sync)
);
endmodule模块说明
wctrl_path
我们来完成wctrl_path的构建，首先明确写这个模块的接口：
module wctrl_path#(
parameter WIDTH = 8,
parameter DEPTH = 16,
parameter ADDR_WD = $clog2(DEPTH)
)(
input wclk,
input wrstn,
input winc,
input [ADDR_WD :0] raddr_sync,
output wenc,
output [ADDR_WD :0] waddr,
output wfull
);写时钟和写复位肯定是必须的，winc是外部的写有效。还有一个必要的输入信号是raddr_sync信号，这个信号的作用是和waddr一起产生写侧看到的fifo_cnt信号，进而得到wfull信号。那么考点1来了：为什么要在写时钟域产生wfull信号，在读时钟域产生rempty信号？
在“【异步FIFO的一些小事·1】空满判断与格雷码”这个博客中已经做过说明，简单而言就是：在写时钟域看到的读指针是有延迟的，对于wfull而言，晚一些看到有数据被读取走也不会影响数据，最多就是wfull信号晚一些撤销而已，而wfull晚撤销不会是数据被覆盖，只会影响到性能（多反压了一会），而性能的问题是可以通过计算一个合理的异步fifo深度开销进行弥补的。同理在读时钟域看到写指针也是有延迟的，因此rempty可能撤销不及时，不及时也没关系最多就是等一会反应过来再读，而不会读取错误数据。
好的，输入信号分析完成，输出信号显然有给ram的wenc和waddr，wdata直接从顶层过去不从这里过手了。还有就是刚刚说的wfull信号。
在“【芯片前端】保持代码手感——同步FIFO”里提到过，考点2：fifo中计算读写地址会用位宽扩一比特的计数器，最高比特作为标志位来判断绕圈，那么把这个模块做一下：
module fifo_cnt#(
parameter DEPTH = 8,
parameter WITDH = $clog2(DEPTH)
)(
input clk,
input rst_n,
input en,
output [WITDH :0] cnt
);
reg [WITDH :0]cnt;
wire cnt_d_h;
wire [WITDH -1:0]cnt_d_l;
assign cnt_d_h = (cnt[WITDH-1:0] == DEPTH-1) ? ~cnt[WITDH] : cnt[WITDH];
assign cnt_d_l = (cnt[WITDH-1:0] == DEPTH-1) ? 0 : cnt[WITDH-1:0] + {{(WITDH-1){1'b0}}, 1'b1};
always @(posedge clk or negedge rst_n)begin
if(~rst_n) cnt <= 0;
else if(en) cnt <= {cnt_d_h, cnt_d_l};
end
endmodule基于这个模块可以轻松的产生waddr，那么进一步得到wenc和wfull的逻辑就非常简单了：
//得到写ram的waddr，fifo_cnt是最高比特为标志位的特殊计数器
assign wenc = winc && (!wfull);
fifo_cnt #(
.DEPTH(DEPTH)
)u_fifo_cnt(
.clk(wclk),
.rst_n(wrstn),
.en(wenc),
.cnt(waddr)
);
//生成wfull信号，wfull信号必须在写时钟域生成，因为读信息延迟到达写时钟域，也不会对wfull信息有影响，不会有数据丢失
wire [ADDR_WD :0]fifo_cnt = (waddr[ADDR_WD] == raddr_sync[ADDR_WD]) ? waddr[ADDR_WD-1:0] - raddr_sync[ADDR_WD-1:0]:
(waddr[ADDR_WD-1:0] + DEPTH - raddr_sync[ADDR_WD-1:0]);
assign wfull = (fifo_cnt == DEPTH);
endmodule 注意这里的waddr还是扩充了一比特的地址，送给ram的时候要取[DEPTH -1:0]，而送到跨异步模块时就直接全位宽送，因为计算fifo_cnt要用到全位宽。
rctrl_path
和wctrl_path的思路一样，不赘述：
module rctrl_path#(
parameter WIDTH = 8,
parameter DEPTH = 16,
parameter ADDR_WD = $clog2(DEPTH)
)(
input rclk,
input rrstn,
input rinc,
input [ADDR_WD :0] waddr_sync,
output renc,
output [ADDR_WD :0] raddr,
output rempty
);
//得到读ram的waddr，fifo_cnt是最高比特为标志位的特殊计数器
assign renc = rinc && (!rempty);
fifo_cnt #(
.DEPTH(DEPTH)
)u_fifo_cnt(
.clk(rclk),
.rst_n(rrstn),
.en(renc),
.cnt(raddr)
);
//生成rempty信号，rempty信号必须在读时钟域生成，因为写信息延迟到达读时钟域，也不会对rempty信息有影响，最多影响读性能
wire [ADDR_WD :0]fifo_cnt = (waddr_sync[ADDR_WD] == raddr[ADDR_WD]) ? waddr_sync[ADDR_WD-1:0] - raddr[ADDR_WD-1:0]:
(waddr_sync[ADDR_WD-1:0] + DEPTH - raddr[ADDR_WD-1:0]);
assign rempty = (fifo_cnt == 0);
endmodule gary_sync_cell
gary_sync_cell专门用来计数器跨异步，思路很简单：二进制输入，转格雷码打拍，跨异步打三拍，格雷码转回二进制输出。那么考点3又来了：为什么异步fifo里要用格雷码跨异步？
基于之前的积累“进阶之路——二进制与格雷码的相互转换模块设计” ，二进制转格雷码和格雷码转二进制的模块直接做：
module b2g_conv #(parameter SIZE = 4
)(
output [SIZE -1:0] gray,
input [SIZE -1:0] binary
);
assign gray = (binary >> 1) ^ binary;
endmodule
module g2b_conv #(
parameter SIZE = 4
)(
output reg [SIZE -1:0] binary,
input [SIZE -1:0] gray
);
integer k;
always @(gray)
begin
for (k = 0; k < SIZE; k = k + 1)
binary[k] = ^(gray >> k);
end
endmoduleOK，那么下一步就是对比特跨异步的问题了。下一个考点4自然就是：多比特如何跨异步？那在这里就不啰嗦了【异步电路碎碎念4】 —— 跨异步的处理方法已经写过 ，欢迎指正。
要做多比特跨异步，当然要先有单比特跨异步模块：
module sync_cell #(
parameter SYNC_CYC = 2
)(
input clk,
input rst_n,
input in,
output out
);
wire [SYNC_CYC :0]in_dff;
assign in_dff[0] = in;
assign out = in_dff[SYNC_CYC];
genvar i;
generate
for(i=1; i<=SYNC_CYC; i=i+1)begin: inst_rtl
dffr u_dffr[i](clk, rst_n, in_dff[i-1], in_dff[i]);
end
endgenerate
endmodule拍数可配，默认是2拍建议配置为3拍，那么考点5：为什么现在跨异步打拍要打3拍？
基于单比特跨异步单元，我们进一步得到多比特跨异步单元：
//将格雷码在目的时钟域打三拍跨异步
wire [WIDTH -1:0]out_data_gray;
genvar i;
generate
for(i=0; i<WIDTH; i=i+1)begin: inst_rtl
sync_cell #(
.SYNC_CYC(SYNC_CYC))
u_sync_cell(
.clk(out_clk),
.rst_n(out_rst_n),
.in(in_data_gray_ff[i]),
.out(out_data_gray[i])
);
end
endgenerate注意千万要用目的时钟打拍啊。
ok，因此完成的gray_sync_cell的代码就有了：
module gary_sync_cell#(
parameter WIDTH = 8,
parameter SYNC_CYC = 3
)(
input in_clk,
input in_rst_n,
input out_clk,
input out_rst_n,
input [WIDTH -1:0] in_data,
output[WIDTH -1:0] out_data
);
//将输入转为格雷码并在源时钟域打一拍
wire [WIDTH -1:0]in_data_gray;
wire [WIDTH -1:0]in_data_gray_ff;
b2g_conv #(
.SIZE(WIDTH))
u_b2g_conv(
.binary(in_data),
.gray(in_data_gray)
);
dffr#(
.WIDTH(WIDTH))
u_in_data_dffr(
.clk(in_clk),
.rst_n(in_rst_n),
.d(in_data_gray),
.q(in_data_gray_ff)
);
//将格雷码在目的时钟域打三拍跨异步
wire [WIDTH -1:0]out_data_gray;
genvar i;
generate
for(i=0; i<WIDTH; i=i+1)begin: inst_rtl
sync_cell #(
.SYNC_CYC(SYNC_CYC))
u_sync_cell(
.clk(out_clk),
.rst_n(out_rst_n),
.in(in_data_gray_ff[i]),
.out(out_data_gray[i])
);
end
endgenerate
//将格雷码转化为二进制
g2b_conv #(
.SIZE(WIDTH))
u_g2b_conv(
.gray(out_data_gray),
.binary(out_data)
);
endmodule双口RAM
用的是默认代码：
module dual_port_RAM #(parameter DEPTH = 16,
parameter WIDTH = 8)(
input wclk ,
input wenc ,
input [$clog2(DEPTH)-1:0] waddr ,
input [WIDTH-1:0] wdata ,
input rclk ,
input renc ,
input [$clog2(DEPTH)-1:0] raddr ,
output reg [WIDTH-1:0] rdata
);
reg [WIDTH-1:0] RAM_MEM [0:DEPTH-1];
always @(posedge wclk) begin
if(wenc)
RAM_MEM[waddr] <= wdata;
end
always @(posedge rclk) begin
if(renc)
rdata <= RAM_MEM[raddr];
end
endmodule 以上，完整的代码呈现。
波形验证
因为主要是叙述个思路，没有做太细致的波形验证，就用auto_verification生成了个简单的验证环境，没有这个工具的请参见【芯片前端】一键生成简易版本定向RTL验证环境的脚本——auto_verification，工具有点些修改，最新的链接是：链接：https://pan.baidu.com/s/1CMptxDGketFHuLeNOLcV0Q，提取码：t6o8。
把所有文件放置于async_fifo目录下，键入auto_verification -f async_fifo，生成仿真环境，简单修改testbench，得到如下波形：
真的是很随意的仿了一下，如果大家发现有问题请不吝赐教~感谢~
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
