关于FIFO和异步处理我已经写过很多东西了:
进阶之路——二进制与格雷码的相互转换模块设计
【异步FIFO的一些小事·0】异步FIFO同步化设计
【异步FIFO的一些小事·1】空满判断与格雷码
【异步FIFO的一些小事·2】异步FIFO中异步走线延时约束的一些思考
【异步FIFO的一些小事·3】异步FIFO中指针走线延时的一些思考
【异步电路碎碎念5】 —— 跨异步处理的几个注意事项
【芯片前端】保持代码手感——同步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的构建,首先明确写这个模块的接口:
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要用到全位宽。
和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专门用来计数器跨异步,思路很简单:二进制输入,转格雷码打拍,跨异步打三拍,格雷码转回二进制输出。那么考点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
endmodule
OK,那么下一步就是对比特跨异步的问题了。下一个考点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
注意千万要用目的时钟打拍啊。
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
用的是默认代码:
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,得到如下波形:
真的是很随意的仿了一下,如果大家发现有问题请不吝赐教~感谢~