Verilog RTL 设计：异步FIFO的设计与验证

之前的两篇博文讨论了同步FIFO的设计和验证，其读写时钟时相同的单一时钟，应用范围有限。

在实际的系统中，经常会遇到多个时钟域传输数据的情况，此时需要数据在跨时钟域上实现无缝传输，且不能有毛刺出现。异步FIFO读写时钟是不相同的，因此可以实现某个频率的写时钟写入再由另一个频率的读时钟读出，也就能够实现跨时钟的传输数据了。

异步FIFO的结构框图如下：

设计的关键：异步FIFO中如何产生空满信号。

        根据同步FIFO方法二的设计经验。空满信号的产生可以根据读写的地址的比较来判断。但是，在异步FIFO中，处于两个不同时钟域的读写地址该如何来比较呢？

        首先，对于空信号，只有在读的时候才会来看FIFO是否为空，如果FIFO为空就不能读数据了，因此空信号的产生是在读时钟域的。同理，对于满信号，只有在写的时候才会来看FIFO是否为满，如果FIFO满了就不能写数据了，因此满信号的产生是在写时钟域的。在进行读写地址的比较时，只能先对地址信号进行时钟域同步，然后再进行比较。采用常规的异步处理的方法：打两拍。

 

//wr_addr_g sample twice
always @(posedge rclk or negedge rst_n)
    if(rst_n == 1'b0)
        {wr_addr_g_dly2,wr_addr_g_dly1} <= 'b0;
    else
        {wr_addr_g_dly2,wr_addr_g_dly1} <= {wr_addr_g_dly1,wr_addr_g};

//rd_addr_g sample twice
always @(posedge wclk or negedge rst_n)
    if(rst_n == 1'b0)
        {rd_addr_g_dly2,rd_addr_g_dly1} <= 'b0;
    else
        {rd_addr_g_dly2,rd_addr_g_dly1} <= {rd_addr_g_dly1,rd_addr_g};

 

 

 

        然后，我们知道地址是一位一位累加的多位宽数据，但在跨时钟采样时，多位宽的数据传输并被采样时，如果不做处理很容易发生亚稳态，从而影响数据正确性。比如六位地址111111会在下一个时刻变成000000，在实际电路中，这个变化过程要持续很长一段时间，会由111111经历6个状态转移到000000.比如111111 -> 101111 -> 100111 -> 100110 -> 100100 -> 000100 -> 000000。由于写时钟与读时钟域不同步，异步的写时钟很可能会在状态不稳定的中间某个状态采样，这样就会得到错误的读指针，进而做出错误的状态判断，导致系统异常（亚稳态问题）。而且由于多位同时突变，凭借概率论常识可知发生错误的可能性很大。因此，将二进制的地址编码转换成对应的格雷码，地址每次只有1个bit发生改变。其结果也不外乎两种：递增前原指针和递增后新指针。显然递增后新指针是最新情况的反映，如果采样到这个指针，那么和我们的设计预期是一致的，如果采样到递增前的原指针，假设现在采样读指针，那么最坏的情况就是把“不满”判断成了“满”，使得本来被允许的写操作被禁止了，但是这并不会对逻辑产生影响，只是带来了写操作的延迟。同样的，如果现在采样写指针，那么最坏的情况就是把“不空”判断成“空”，使得本来被允许的读操作被禁止了，但是这也不会对逻辑产生影响，只是带来了读操作的延迟。二进制码转换成格雷码，其法则是保留二进制码的最高位作为格雷码的最高位，而次高位格雷码为二进制码的高位与次高位相异或，而格雷码其余各位与次高位的求法相类似。这样就可以实现二进制到格雷码的转换了，总结就是移位并且异或，verilog代码实现就一句：assign wgraynext = (wbinnext>>1) ^ wbinnext。

 

//binary code to gray code
assign  wr_addr_g = (wr_addr_b>>1) ^ wr_addr_b;
assign  rd_addr_g = (rd_addr_b>>1) ^ rd_addr_b;

 

 

 

        最后，需要解决的问题就是格雷码如何进行比较产生空满信号。空信号很简单，当读地址和写地址相同时，即产生空信号。对于满信号，参考下面的表格发现，格雷码的0-15、1-14、2-13...都是最高位相反其余低位相同，同时，为判断满信号，又会多出一个最高位，而在FIFO满时，读写地址的最高位也是相反的。所以总结如下：当读写地址的高2bit的相反，后几位的bit相同时，写满；当读写地址相等时，读空。

 

assign  empty = (rd_addr_g == wr_addr_g_dly2);
assign  full  = (wr_addr_g == {~rd_addr_g_dly2[ADDR_WIDTH:ADDR_WIDTH-1],rd_addr_g_dly2[ADDR_WIDTH-2:0]});

 

 

 

十进制数	二进制数	格雷码		十进制数	二进制数	格雷码
0	0000	0000		8	1000	1100
1	0001	0001		9	1001	1101
2	0010	0011		10	1010	1111
3	0011	0010		11	1011	1110
4	0100	0110		12	1100	1010
5	0101	0111		13	1101	1011
6	0110	0101		14	1110	1001
7	0111	0100		15	1111	1000

 

 

根据上述分析，异步FIFO的设计如下：

RTL：

module async_fifo #(parameter FIFO_WIDTH = 8,
                              FIFO_DEPTH = 16,
                              ADDR_WIDTH = 4)
(
  input   wire                  rclk,
  input   wire                  wclk,
  input   wire                  rst_n,
  input   wire                  wr_en,
  input   wire                  rd_en,
  input   wire[FIFO_WIDTH-1:0]  wr_data,
  output  reg [FIFO_WIDTH-1:0]  rd_data,
  output  reg                   empty,
  output  reg                   full
);
//memory
reg [FIFO_WIDTH-1:0]            mem[FIFO_DEPTH-1:0];
//address
reg [ADDR_WIDTH-1:0]            wr_addr,rd_addr;
//binary adderss
reg [ADDR_WIDTH:0]              wr_addr_b,rd_addr_b;
//gray address
wire[ADDR_WIDTH:0]              wr_addr_g,rd_addr_g;
//sample gray address
reg [ADDR_WIDTH:0]              wr_addr_g_dly1,wr_addr_g_dly2,rd_addr_g_dly1,rd_addr_g_dly2;

//binary code to gray code
assign  wr_addr_g = (wr_addr_b>>1) ^ wr_addr_b;
assign  rd_addr_g = (rd_addr_b>>1) ^ rd_addr_b;
//addr
assign  wr_addr = wr_addr_b[ADDR_WIDTH-1:0];
assign  rd_addr = rd_addr_b[ADDR_WIDTH-1:0];

//read & write allow
wire    rd_allow = rd_en && !empty;
wire    wr_allow = wr_en && !full;

//write data
always @(posedge wclk or negedge rst_n)
    if(rst_n == 1'b0)
        wr_addr_b <= 'b0;
    else if(wr_allow) begin
        mem[wr_addr] <= wr_data;
        wr_addr_b <= wr_addr_b + 1'b1;
    end

//read data
always @(posedge rclk or negedge rst_n)
    if(rst_n == 1'b0)
        rd_addr_b <= 'b0;
    else if(rd_allow) begin
        rd_data <= mem[rd_addr];
        rd_addr_b <= rd_addr_b + 1'b1;
    end

//wr_addr_g sample twice
always @(posedge rclk or negedge rst_n)
    if(rst_n == 1'b0)
        {wr_addr_g_dly2,wr_addr_g_dly1} <= 'b0;
    else
        {wr_addr_g_dly2,wr_addr_g_dly1} <= {wr_addr_g_dly1,wr_addr_g};

//rd_addr_g sample twice
always @(posedge wclk or negedge rst_n)
    if(rst_n == 1'b0)
        {rd_addr_g_dly2,rd_addr_g_dly1} <= 'b0;
    else
        {rd_addr_g_dly2,rd_addr_g_dly1} <= {rd_addr_g_dly1,rd_addr_g};

assign  empty = (rd_addr_g == wr_addr_g_dly2);
assign  full  = (wr_addr_g == {~rd_addr_g_dly2[ADDR_WIDTH:ADDR_WIDTH-1],rd_addr_g_dly2[ADDR_WIDTH-2:0]});

endmodule

Testbench：

`timescale 1ns/1ps
module async_fifo_tb();

parameter       FIFO_WIDTH = 8,
                FIFO_DEPTH = 16,
                ADDR_WIDTH = 4;

reg                     rclk,wclk,rst_n,wr_en,rd_en;
reg [FIFO_WIDTH-1:0]    wr_data;
wire[FIFO_WIDTH-1:0]    rd_data;
wire                    empty,full;

async_fifo 
#(  .FIFO_WIDTH (FIFO_WIDTH),
    .FIFO_DEPTH (FIFO_DEPTH),
    .ADDR_WIDTH (ADDR_WIDTH)
)
(
  .rclk     (rclk   ),
  .wclk     (wclk   ),
  .rst_n    (rst_n  ),
  .wr_en    (wr_en  ),
  .rd_en    (rd_en  ),
  .wr_data  (wr_data),
  .rd_data  (rd_data),
  .empty    (empty  ),
  .full     (full   )
);

initial begin
    rst_n=0;
    rclk=0;
    wclk=0;
    #5
    rst_n=1;
end

always #30 rclk=~rclk;
always #20 wclk=~wclk;

initial begin
    wr_en=0;
    rd_en=0;
    #50
    wr_en=1;
    wr_data=8'h0;
    #40 wr_data=8'h1;
    #40 wr_data=8'h2;
    #40 wr_data=8'h3;
    #40 wr_data=8'h4;
    #40 wr_data=8'h5;
    #40 wr_data=8'h6;
    #40 wr_data=8'h7;
    #40 wr_data=8'h8;
    #40 wr_data=8'h9;
    #40 wr_data=8'hA;
    #40 wr_data=8'hB;
    #40 wr_data=8'hC;
    #40 wr_data=8'hD;
    #40 wr_data=8'hE;
    #40 wr_data=8'hF;
    #60
    wr_en=0;
    rd_en=1;
    #1000
    $finish;
end

`include "vpd.inc"

endmodule

DVE波形：

 

 在此记录异步FIFO的设计和验证。