FIFO（First In First Out）是異步數(shù)據(jù)傳輸時經(jīng)常使用的存儲器。該存儲器的特點是數(shù)據(jù)先進(jìn)先出（后進(jìn)后出）。其實，多位寬數(shù)據(jù)的異步傳輸問題，無論是從快時鐘到慢時鐘域，還是從慢時鐘到快時鐘域，都可以使用 FIFO 處理。

FIFO 原理

工作流程

(1) 復(fù)位之后，在寫時鐘和非滿狀態(tài)信號的控制下，數(shù)據(jù)可以寫入 FIFO 中。RAM 的寫地址從 0 開始，每寫一次數(shù)據(jù)寫地址指針加一，指向下一個存儲單元。當(dāng) FIFO 寫滿后，數(shù)據(jù)將不能再寫入，否則數(shù)據(jù)會因覆蓋而丟失。

(2) FIFO 數(shù)據(jù)為非空、或滿狀態(tài)時，在讀時鐘和非空狀態(tài)信號的控制下，數(shù)據(jù)可以從 FIFO 中讀出。RAM 的讀地址從 0 開始，每讀一次數(shù)據(jù)讀地址指針加一，即指向下一個存儲單元。當(dāng) FIFO 讀空后，就不能再讀數(shù)據(jù)，否則讀出的數(shù)據(jù)將是錯誤的。

(3) FIFO 的存儲結(jié)構(gòu)為雙口 RAM，允許讀寫同時進(jìn)行。FIFO 的讀寫指針是循環(huán)計數(shù)的，即 讀寫指針對應(yīng)的 RAM 地址超過 FIFO 深度時，會溢出歸零，重新計數(shù)。

典型異步 FIFO 結(jié)構(gòu)圖如下所示。相關(guān)信號及空滿狀態(tài)的原理將在下面一一說明。

讀寫時刻

(1) 關(guān)于寫時刻，只要 FIFO 中數(shù)據(jù)為非滿狀態(tài)，就可以進(jìn)行寫操作；如果 FIFO 為滿狀態(tài)，則禁止再寫數(shù)據(jù)。

(2) 關(guān)于讀時刻，只要 FIFO 中數(shù)據(jù)為非空狀態(tài)，就可以進(jìn)行讀操作；如果 FIFO 為空狀態(tài)，則禁止再讀數(shù)據(jù)。

(3) 總之，如果一段時間內(nèi)不間斷的對 FIFO 同時進(jìn)行讀寫操作，則要求寫 FIFO 速率不能大于讀 FIFO 速率。

讀空狀態(tài)

(1) 復(fù)位時，F(xiàn)IFO 中沒有數(shù)據(jù)，空狀態(tài)信號拉高。當(dāng) FIFO 被寫入數(shù)據(jù)后，空狀態(tài)信號拉低，表示非空狀態(tài)。當(dāng)讀數(shù)據(jù)地址追趕上寫地址，即讀寫地址都相等時，F(xiàn)IFO 為空狀態(tài)。

(2) 因為 FIFO 是異步的，所以讀寫地址進(jìn)行比較時，需要同步打拍邏輯，就需要耗費一定的時間。因此，空狀態(tài)的指示信號不是實時的，會有一定的延時。如果在這段延遲時間內(nèi)又有新的數(shù)據(jù)寫入 FIFO，就會出現(xiàn)空狀態(tài)指示信號有效，但實際上 FIFO 中存在數(shù)據(jù)的現(xiàn)象。

(3) 嚴(yán)格來講該空狀態(tài)指示是錯誤的。但是產(chǎn)生空狀態(tài)的意義在于防止讀操作對空狀態(tài)的 FIFO 進(jìn)行數(shù)據(jù)讀取。產(chǎn)生空狀態(tài)信號時，實際 FIFO 中有數(shù)據(jù)，相當(dāng)于提前判斷了空狀態(tài)信號，此時不再進(jìn)行讀 FIFO 操作也是安全的。所以，該設(shè)計從應(yīng)用上來說是沒有問題的。

(4) 牢記，讀空狀態(tài)信號，是在讀時鐘域產(chǎn)生的。

寫滿狀態(tài)

(1) 復(fù)位時，F(xiàn)IFO 中沒有數(shù)據(jù)，滿信號是拉低的，表示 FIFO 中的數(shù)據(jù)沒有寫滿 (其實 FIFO 是空的 )。當(dāng) FIFO 開始寫數(shù)據(jù)且讀操作不進(jìn)行或讀速率相對較慢時，只要寫數(shù)據(jù)地址超過讀數(shù)據(jù)地址的 FIFO 深度時，便會產(chǎn)生滿狀態(tài)信號。此時寫地址和讀地址也是相等的，但是意義是不一樣的。

(2) 此時經(jīng)常使用多余的 1bit 分別當(dāng)做讀寫地址的拓展位，來區(qū)分讀寫地址相同的時候，F(xiàn)IFO 的狀態(tài)是空還是滿狀態(tài)。當(dāng)讀寫地址與拓展位均相同的時候，表明讀寫數(shù)據(jù)的數(shù)量是一致的，則此時 FIFO 是空狀態(tài)。如果讀寫地址相同，拓展位相反，表明寫數(shù)據(jù)的數(shù)量已經(jīng)超過讀數(shù)據(jù)數(shù)量的一個 FIFO 深度了，此時 FIFO 是滿狀態(tài)。當(dāng)然，此條件成立的前提是空狀態(tài)禁止讀操作、滿狀態(tài)禁止寫操作。

(3) 同理，由于異步延遲邏輯的存在，滿狀態(tài)信號也不是實時的。但是也相當(dāng)于提前判斷了滿狀態(tài)信號，此時不再進(jìn)行寫 FIFO 操作也不會影響應(yīng)用的正確性。

(4) 牢記，寫滿狀態(tài)信號，是在寫時鐘域產(chǎn)生的。

格雷碼

(1) 當(dāng)讀寫時鐘都是同一個時鐘時，此時 FIFO 是同步的，直接對讀寫指針進(jìn)行比對，產(chǎn)生空、滿信號即可。

(2) 當(dāng)讀寫時鐘是異步的時候，因為讀時鐘域產(chǎn)生讀空信號，寫時鐘域產(chǎn)生寫滿信號，所以產(chǎn)生空邏輯信號時，需要將寫指針同步到讀時鐘域，再與讀指針進(jìn)行比較；產(chǎn)生滿邏輯信號時，需要將讀指針同步到寫時鐘域，再與寫指針進(jìn)行比較。

(3) 因為讀寫指針的信號寬度一般都是大于 1bit 的，所以同步處理時不能直接對多位寬的讀寫指針進(jìn)行延遲打拍，需要借助格雷碼對讀寫指針進(jìn)行轉(zhuǎn)換，保證每一個周期內(nèi)地址指針只有 1bit 變化，然后再進(jìn)行延遲打拍的同步處理。

(4) 4bit 的二進(jìn)制碼與格雷碼之間的變化關(guān)系如下所示，其中 ⊕ 表示異或操作符。由圖可知，二進(jìn)制碼對應(yīng)的十六進(jìn)制碼遞增時，二進(jìn)制碼對應(yīng)的相鄰的兩個格雷碼之間只有 1bit 數(shù)據(jù)有變化。當(dāng)多位寬信號每次只有 1bit 數(shù)據(jù)變化時，可以使用延遲打拍的方法對其進(jìn)行同步處理。

(5) 下面對空邏輯的產(chǎn)生進(jìn)行舉例說明：

5.1) 首先需要對寫指針 waddr 進(jìn)行組合邏輯的格雷碼變換 waddr_gray。

5.2) 為了保證 waddr_gary 在讀時鐘域每次被采集時只有 1bit 數(shù)據(jù)變化，則 waddr_gray 需要在其源時鐘域即寫時鐘域進(jìn)行一拍緩存 waddr_gray_d。因為 waddr 到 waddr_gray 的組合邏輯變換時，每次兩者之間不只是有 1bit 變化的。

5.3) 在讀時鐘域?qū)?waddr_gray_d 進(jìn)行打拍同步，得到讀時鐘域同步后的寫指針為 waddr_gray_rclk。

5.4) 根據(jù)格雷碼變換規(guī)則，空信號有效時二進(jìn)制碼相等的讀寫指針，變?yōu)楦窭状a之后仍然相等。所以直接使用 waddr_gray_rclk 與讀指針進(jìn)行組合邏輯變換后的格雷碼進(jìn)行相等比較，即可產(chǎn)生讀空信號邏輯。

5.5) 需要說明的是，滿信號有效時，帶有拓展位的讀寫指針高 1bit 相反、低位相同。所以變?yōu)楦窭状a之后，寫滿信號產(chǎn)生的條件，則是讀寫指針高 2bit 相反、低位相同 (請讀者思考一下為什么？)。

FIFO 設(shè)計

設(shè)計要求

為設(shè)計應(yīng)用于各種場景的 FIFO，這里對設(shè)計提出如下要求：

(1) FIFO 是異步的，即讀寫控制信號來自不同的時鐘域。

(2) FIFO 深度、寬度參數(shù)化，輸出空、滿狀態(tài)信號，并輸出一個可配置的滿狀態(tài)信號。當(dāng) FIFO 內(nèi)部數(shù)據(jù)達(dá)到設(shè)置的參數(shù)數(shù)量時，該信號拉高，此時需要對格雷碼進(jìn)行反解碼。

(3) 輸入數(shù)據(jù)和輸出數(shù)據(jù)位寬可以不一致，但要保證寫數(shù)據(jù)、寫地址位寬與讀數(shù)據(jù)、讀地址位寬的一致性。例如寫數(shù)據(jù)位寬 8bit，寫地址位寬為 6bit（64 個數(shù)據(jù)）。如果輸出數(shù)據(jù)位寬要求 32bit，則輸出地址位寬應(yīng)該為 4bit（16 個數(shù)據(jù)）。

雙口 RAM 設(shè)計

RAM 地址位寬、數(shù)據(jù)位寬等端口參數(shù)可配置，讀寫位寬一致。實際中 RAMDP（Dual Port） 是需要使用 Memory IP 的，這里創(chuàng)建的 RAM 并沒有考慮到異步問題。

Verilog 描述如下。

module  ramdp
  #(  parameter       AW     = 5 ,
      parameter       DW     = 16
   )
   (
    input                   CLK_WR , //寫時鐘
    input [DW-1:0]          D ,      //寫數(shù)據(jù)
    input                   WR_EN ,  //寫使能
    input [AW-1:0]          ADDR_WR ,//寫地址
    input                   CLK_RD , //讀時鐘
    input                   RD_EN ,  //讀使能
    input [AW-1:0]          ADDR_RD ,//讀地址
    output reg [DW-1:0]     Q        //讀數(shù)據(jù)
    );

   reg [DW-1:0]                 mem [(1<

計數(shù)器設(shè)計

計數(shù)器用于產(chǎn)生讀寫地址信息，位寬可配置，不需要設(shè)置結(jié)束值，讓其溢出后自動重新計數(shù)即可。同時該計數(shù)器還具有格雷碼轉(zhuǎn)換與緩存的功能。

Verilog 描述如下。

module  ccnt_gray
  #(parameter W = 32'd8
    )
   (
    input              rstn ,
    input              clk ,
    input              en ,
    output [W-1:0]     cnt ,
    output [W-1:0]     cnt_gray ,
    output [W-1:0]     cnt_gray_d
    );


   reg [W-1:0]          cnt_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt_r        <= 'b0 ;
      end
      else if (en) begin
         cnt_r        <= cnt_r + 1'b1 ;
      end
   end
   assign cnt = cnt_r ;
   assign cnt_gray      = cnt ^ (cnt>>1);


   reg [W-1:0]          cnt_gray_buf ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         cnt_gray_buf   <= 'b0 ;
      end
      else begin
         cnt_gray_buf   <= cnt_gray ;
      end
   end
   assign cnt_gray_d = cnt_gray_buf ;


endmodule

多位寬數(shù)據(jù)同步設(shè)計

讀寫指針進(jìn)行格雷碼變換并緩存后，每一個計數(shù)周期內(nèi)地址指針只有 1bit 變化，所以可以直接使用延遲打拍的方法進(jìn)行同步。數(shù)據(jù)寬度、同步級數(shù)均可配置。

Verilog 描述如下。

module  data1c_sync
  #(parameter DW    = 8,
    parameter STAGE = 3
    )
   (
    input              rstn ,
    input              clk ,
    input [DW-1:0]     data_in ,
    output [DW-1:0]    data_out
    );


   reg [DW-1: 0]       data_r [STAGE-1: 0];
   integer             i ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         for (i=0; i

格雷碼反解碼

因為該 FIFO 還存在一個可配置的滿狀態(tài)信號輸出，所以需要對格雷碼同步后的讀指針進(jìn)行反解碼，然后在寫時鐘域與寫指針進(jìn)行比較，以判讀當(dāng)前 FIFO 中數(shù)據(jù)的具體個數(shù)。

module  gray_decode
  #(parameter W = 32'd8
    )
   (
    input [W-1:0]      gray ,
    output [W-1:0]     gray_decode
    );


   integer             i ;
   reg [W-1:0] gray_decode_r ;
   always @(*) begin
      gray_decode_r[W-1]        = gray[W-1];
      for (i=W-2; i>=0; i=i-1) begin
         gray_decode_r[i]     = gray_decode_r[i+1] ^ gray[i];
      end
   end


   assign gray_decode = gray_decode_r ;
endmodule

FIFO 設(shè)計

該模塊為 FIFO 的主體部分，產(chǎn)生讀寫控制邏輯，包括讀寫指針、讀寫有效時刻以及空、滿、可編程滿狀態(tài)的邏輯。

實際上此模塊已經(jīng)是典型的 FIFO 設(shè)計，有需要的讀者可以直接使用該層次的 FIFO 代碼進(jìn)行測試，甚至應(yīng)用到自己的設(shè)計之中。

module  fifo
    #(  parameter       DW        = 16 ,
        parameter       DEPTH     = 32 ,
        parameter       PROG_DEPTH = 16) //可設(shè)置深度
    (
        input                   rstn,  //讀寫使用一個復(fù)位
        input                   wclk,  //寫時鐘
        input                   wren,  //寫使能
        input [DW-1: 0]         wdata, //寫數(shù)據(jù)
        output                  wfull,    //寫滿標(biāo)志
        output                  prog_full, //可編程滿標(biāo)志
        input                   rclk,  //讀時鐘
        input                   rden,  //讀使能
        output [DW-1 : 0]       rdata, //讀數(shù)據(jù)
        output                  rempty   //讀空標(biāo)志
     );


   localparam AW = log2b(DEPTH);
   //==================== push/wr counter ===============
   //wptr/waddr using one more bit to indict new-loop
   wire [AW:0]          waddr ;
   wire [AW:0]          waddr_gray ;
   wire [AW:0]          waddr_gray_d ;
   ccnt_gray        #(.W(AW+1))
   u_push_cnt(
      .rstn             (rstn),
      .clk              (wclk),
      .en               (wren && !wfull), //full 時禁止寫
      .cnt              (waddr),
      .cnt_gray         (waddr_gray),
      .cnt_gray_d       (waddr_gray_d)
      );


   // sync: wptr from wclk to rclk
   wire [AW:0]          waddr_gray_rclk ;
   data1c_sync   #(.DW(AW+1), .STAGE(3))
   u_waddr_to_rclk
   (
      .rstn        (rstn),
      .clk         (rclk),
      .data_in     (waddr_gray_d),
      .data_out    (waddr_gray_rclk)
    );
   //============== pop/rd counter ===================
   wire [AW:0]          raddr ;
   wire [AW:0]          raddr_gray ;
   wire [AW:0]          raddr_gray_d ;
   ccnt_gray        #(.W(AW+1))
   u_pop_cnt(
      .rstn             (rstn),
      .clk              (rclk),
      .en               (rden && !rempty), //full 時禁止寫
      .cnt              (raddr),
      .cnt_gray         (raddr_gray),
      .cnt_gray_d       (raddr_gray_d)
      );
   // sync: rdtr from rclk to wclk
   wire [AW:0]          raddr_gray_wclk ;
   data1c_sync   #(.DW(AW+1), .STAGE(3) )
   u_raddr_to_wclk
   (
       .rstn        (rstn),
       .clk         (wclk),
       .data_in     (raddr_gray_d),
       .data_out    (raddr_gray_wclk)
    );
   //============== full/empty logic ===================
   //(1) empty logic
   assign rempty = (raddr_gray == waddr_gray_rclk);




   //(2) full logic
   assign wfull  = (waddr_gray[AW:AW-1] == ~raddr_gray_wclk[AW:AW-1]) &&
                   (waddr_gray[AW-2:0] == raddr_gray_wclk[AW-2:0]) ;


   //(3) porgrammable full
   //waddr gray decode
   wire [AW:0]          raddr_degray_wclk ;
   gray_decode  #(.W(AW+1))
   u_waddr_degray_rclk (
       .gray            (raddr_gray_wclk),
       .gray_decode     (raddr_degray_wclk)
     );
   //prog full
   wire [AW:0]  waddr_delta = waddr >= raddr_degray_wclk ?
                              (waddr - raddr_degray_wclk) :
                              ((1<<(AW+1)) + waddr - raddr_degray_wclk) ;
   assign       prog_full   = waddr_delta >= PROG_DEPTH ;


   //雙口 ram 例化
   ramdp     #(.AW(AW), .DW (DW))
   u_ramdp
     (
      .CLK_WR          (wclk),
      .WR_EN           (wren & !wfull), //寫滿時禁止寫
      .ADDR_WR         (waddr[AW-1:0]),
      .D               (wdata[DW-1:0]),
      .CLK_RD          (rclk),
      .RD_EN           (rden & !rempty), //讀空時禁止讀
      .ADDR_RD         (raddr[AW-1:0]),
      .Q               (rdata[DW-1:0])
      );


   function  integer log2b ;
      input     integer depth ;
      for (log2b=0; (1<

FIFO 調(diào)用

下面可以調(diào)用設(shè)計的 FIFO，完成多位寬數(shù)據(jù)傳輸?shù)漠惒教幚怼?/p>

寫數(shù)據(jù)位寬為 4bit，寫深度為 32。

讀數(shù)據(jù)位寬為 16bit，讀深度為 8，可配置 full 深度為 16。

該模塊只是 FIFO 的一個具體應(yīng)用，用于數(shù)據(jù)的異步傳輸、緩存與整合。

//ensure write rate < read rate
module  fifo_buf
  #(  parameter       DWI        = 4 , //width 4
      parameter       AWI        = 5 , //depth 32
      parameter       DWO        = 16 ,
      parameter       AWO        = 3 ,
      parameter       PROG_DEPTH = 16
   )
   (
      input                     rstn,  //讀寫使用一個復(fù)位
      //data in
      input                     din_clk,  //寫時鐘
      input                     din_en,  //寫使能
      input [DWI-1: 0]          din, //寫數(shù)據(jù)
      //data out
      input                     dout_clk,  //讀時鐘
      output                    dout_valid,  //讀使能
      output [DWO-1 : 0]        dout //讀數(shù)據(jù)
    );


   wire                         wfull ;    //寫滿標(biāo)志
   wire                         prog_full ; //可編程滿標(biāo)志
   wire                         rempty ;   //讀空標(biāo)志
   wire [DWI-1:0]               rdata_fifo ;
   wire                         rden_fifo ;
   fifo  #(.DW(DWI), .DEPTH(1<

testbench

testbench 描述如下，用于測試空、滿邏輯信號，以及讀寫操作。測試中只列舉了輸入數(shù)據(jù)位寬小于輸出數(shù)據(jù)位寬的情景。

`timescale 1ns/1ns
`define SMALL2BIG


module test ;
`ifdef SMALL2BIG
   reg          rstn ;
   reg          clk_slow, clk_fast ;
   reg [3:0]    din ;
   reg          din_en ;
   wire [15:0]  dout ;
   wire         dout_valid ;


   //reset
   initial begin
      clk_slow  = 0 ;
      clk_fast  = 0 ;
      rstn      = 0 ;
      #50 rstn  = 1 ;
   end


   //讀時鐘 clock_slow 較快于寫時鐘 clk_fast 的 1/4
   //保證讀數(shù)據(jù)稍快于寫數(shù)據(jù)
   parameter CYCLE_WR = 40 ;
   always #(CYCLE_WR/2/4) clk_fast = ~clk_fast ;
   always #(CYCLE_WR/2-1) clk_slow = ~clk_slow ;


   //data generate
   initial begin
      din       = 16'h4321 ;
      din_en    = 0 ;
      wait (rstn) ;
      //(1) 測試 full、prog_full、empyt 信號
      force test.u_data_buf.u_fifo.rden = 1'b0 ;
      repeat(32) begin
         @(negedge clk_fast) ;
         din_en = 1'b1 ;
         din    = {$random()} % 16;
      end
      @(negedge clk_fast) din_en = 1'b0 ;


      //(2) 測試數(shù)據(jù)讀寫
      #500 ;
      rstn = 0 ;
      #10 rstn = 1 ;
      release test.u_data_buf.u_fifo.rden ;
      repeat(60) begin
         @(negedge clk_fast) ;
         if (!test.u_data_buf.u_fifo.wfull) begin
            din_en = 1'b1 ;
            din    = {$random()} % 16;
         end
         else begin
            din_en = 1'b0 ;
         end
      end


      //(3) 停止讀取再一次測試 empyt、full、prog_full 信號
      #800 ;
      force test.u_data_buf.u_fifo.rden = 1'b0 ;
      repeat(18) begin
         @(negedge clk_fast) ;
         din_en = 1'b1 ;
         din    = {$random()} % 16;
      end
   end


   fifo_buf #(.DWI(4), .AWI(5), .DWO(16), .AWO(3), .PROG_DEPTH(16))
     u_data_buf(
        .rstn           (rstn),
        .din_clk        (clk_fast),
        .din            (din),
        .din_en         (din_en),
        .dout_clk       (clk_slow),
        .dout           (dout),
        .dout_valid     (dout_valid));


`else // !`ifdef SMALL2BIG
`endif


   //stop sim
   initial begin
      forever begin
         #100;
         if ($time >= 5000)  $finish ;
      end
   end


endmodule

仿真分析

根據(jù) testbench 中的 3 步測試激勵，分析如下：

測試 (1) : FIFO 端口及一些內(nèi)部信號時序結(jié)果如下。

由圖可知，F(xiàn)IFO 內(nèi)部開始寫數(shù)據(jù)，空狀態(tài)信號 rempty 拉低（紅色 M1 ) 之前有一段時間延遲，這是寫地址同步延時導(dǎo)致的。

由于此時沒有進(jìn)行讀 FIFO 操作，所以 prog_full 與 full 拉高 (黃色 M2 與綠色 M3) 幾乎沒有延遲。

測試 (2) : FIFO 同時進(jìn)行讀寫時，fifo 與 fifo_buf 模塊的端口信號如下所示。

由圖可知，數(shù)據(jù)開始傳輸時，fifo 模塊的等位寬數(shù)據(jù)輸出、fifo_buf 整合之后的數(shù)據(jù)輸出，均與輸入數(shù)據(jù)對應(yīng)，沒有傳輸錯誤。

測試 (3) ：整個 FIFO 讀寫行為及讀停止的時序仿真圖如下所示。

由圖可知，讀寫操作同時進(jìn)行時，wfull 信號會不斷翻轉(zhuǎn) （M4 時刻之前），這是因為此時 fifo 的使用方法是非滿即寫，非空即讀。

M4 時刻禁止寫操作后（din_en 恒為 0），由于讀一致存在，所以 full 信號會拉低并保持，表示 fifo 中數(shù)據(jù)一直未滿。而 prog_full 也會相繼拉低 (M5 時刻)，表示 FIFO 中的數(shù)據(jù)已經(jīng)低于配置的數(shù)目。

當(dāng)恢復(fù)寫操作后 （din_en 恒為 1，對應(yīng) M6 時刻），prog_full 與 full 信號相繼拉高。