前言
关于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
我们来完成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 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<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，得到如下波形：
真的是很随意的仿了一下，如果大家发现有问题请不吝赐教~感谢~
