Subversion Repositories mpeg2fpga

/*

 * xilinx_fifo216.v

 *

 * Copyright (c) 2007 Koen De Vleeschauwer.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/*

 * FIFO216

 * Connect three 72-bit wide FIFO36_72 in parallel to create one 216-bit wide fifo.

 */

`include "timescale.v"

module FIFO216 (ALMOSTEMPTY, ALMOSTFULL, DO, EMPTY, FULL, RDERR, WRERR, DI, RDCLK, RDEN, RST, WRCLK, WREN);

  parameter [8:0]ALMOST_FULL_OFFSET=9'h080;

  parameter [8:0]ALMOST_EMPTY_OFFSET=9'h080;

  parameter DO_REG=1;

  parameter EN_SYN="FALSE";

  output ALMOSTEMPTY;

  output ALMOSTFULL;

  output [215:0]DO;

  output EMPTY;

  output FULL;

  output reg RDERR;

  output reg WRERR;

  input [215:0]DI;

  input RDCLK;

  input RDEN;

  input RST;

  input WRCLK;

  input WREN;

  wire fifo_wren;

  wire fifo_rden;

  wire [63:0]fifo1_di;

  wire [7:0]fifo1_dip;

  wire [63:0]fifo1_do;

  wire [7:0]fifo1_dop;

  wire fifo1_empty;

  wire fifo1_full;

  wire fifo1_almost_empty;

  wire fifo1_almost_full;

  wire fifo1_rderr;

  wire fifo1_wrerr;

  wire [63:0]fifo2_di;

  wire [7:0]fifo2_dip;

  wire [63:0]fifo2_do;

  wire [7:0]fifo2_dop;

  wire fifo2_empty;

  wire fifo2_full;

  wire fifo2_almost_empty;

  wire fifo2_almost_full;

  wire fifo2_rderr;

  wire fifo2_wrerr;

  wire [63:0]fifo3_di;

  wire [7:0]fifo3_dip;

  wire [63:0]fifo3_do;

  wire [7:0]fifo3_dop;

  wire fifo3_empty;

  wire fifo3_full;

  wire fifo3_almost_empty;

  wire fifo3_almost_full;

  wire fifo3_rderr;

  wire fifo3_wrerr;

  assign DO = {fifo3_dop, fifo3_do, fifo2_dop, fifo2_do, fifo1_dop, fifo1_do};

  assign {fifo3_dip, fifo3_di, fifo2_dip, fifo2_di, fifo1_dip, fifo1_di} = DI;

  assign EMPTY = fifo1_empty || fifo2_empty || fifo3_empty;

  assign FULL = fifo1_full || fifo2_full || fifo3_full;

  assign ALMOSTEMPTY = fifo1_almost_empty || fifo2_almost_empty || fifo3_almost_empty;

  assign ALMOSTFULL = fifo1_almost_full || fifo2_almost_full || fifo3_almost_full;

  always @(posedge RDCLK)

    if (RST) RDERR <= 1'b0;

    else RDERR <= RDEN && EMPTY;

  always @(posedge WRCLK)

    if (RST) WRERR <= 1'b0;

    else WRERR <= WREN && FULL;

  assign fifo_wren = WREN && ~FULL;

  assign fifo_rden = RDEN && ~EMPTY;

  // FIFO36_72: 72x36k Synchronous/Asynchronous BlockRAM FIFO /w ECC

  //             Virtex-5

  // Xilinx HDL Libraries Guide, version 8.2.2

  FIFO36_72 #(

     .ALMOST_FULL_OFFSET(ALMOST_FULL_OFFSET),   // Sets almost full threshold

     .ALMOST_EMPTY_OFFSET(ALMOST_EMPTY_OFFSET), // Sets the almost empty threshold

     .DO_REG(DO_REG),                           // Enable output register (0 or 1)

                                                //   Must be 1 if EN_SYN = "FALSE"

     .EN_ECC_READ("FALSE"),                     // Enable ECC decoder, "TRUE" or "FALSE"

     .EN_ECC_WRITE("FALSE"),                    // Enable ECC encoder, "TRUE" or "FALSE"

     .EN_SYN(EN_SYN),                           // Specifies FIFO as Asynchronous ("FALSE")

                                                //   or Synchronous ("TRUE")

     .FIRST_WORD_FALL_THROUGH("FALSE")          // Sets the FIFO FWFT to "TRUE" or "FALSE

  ) FIFO36_72_slice0 (

     .ALMOSTEMPTY(fifo1_almost_empty),          // 1-bit almost empty output flag

     .ALMOSTFULL(fifo1_almost_full),            // 1-bit almost full output flag

     .DBITERR(),                                // 1-bit double bit error status output

     .DO(fifo1_do),                             // 64-bit data output

     .DOP(fifo1_dop),                           // 8-bit parity data output

     .ECCPARITY(),                              // 8-bit generated error correction parity

     .EMPTY(fifo1_empty),                       // 1-bit empty output flag

     .FULL(fifo1_full),                         // 1-bit full output flag

     .RDCOUNT(),                                // 9-bit read count output

     .RDERR(fifo1_rderr),                       // 1-bit read error output

     .SBITERR(),                                // 1-bit single bit error status output

     .WRCOUNT(),                                // 9-bit write count output

     .WRERR(fifo1_wrerr),                       // 1-bit write error

     .DI(fifo1_di),                             // 64-bit data input

     .DIP(fifo1_dip),                           // 8-bit parity input

     .RDCLK(RDCLK),                             // 1-bit read clock input

     .RDEN(fifo_rden),                          // 1-bit read enable input

     .RST(RST),                                 // 1-bit reset input

     .WRCLK(WRCLK),                             // 1-bit write clock input

     .WREN(fifo_wren)                           // 1-bit write enable input

  );

  // FIFO36_72: 72x36k Synchronous/Asynchronous BlockRAM FIFO /w ECC

  //             Virtex-5

  // Xilinx HDL Libraries Guide, version 8.2.2

  FIFO36_72 #(

     .ALMOST_FULL_OFFSET(ALMOST_FULL_OFFSET),   // Sets almost full threshold

     .ALMOST_EMPTY_OFFSET(ALMOST_EMPTY_OFFSET), // Sets the almost empty threshold

     .DO_REG(DO_REG),                           // Enable output register (0 or 1)

                                                //   Must be 1 if EN_SYN = "FALSE"

     .EN_ECC_READ("FALSE"),                     // Enable ECC decoder, "TRUE" or "FALSE"

     .EN_ECC_WRITE("FALSE"),                    // Enable ECC encoder, "TRUE" or "FALSE"

     .EN_SYN(EN_SYN),                           // Specifies FIFO as Asynchronous ("FALSE")

                                                //   or Synchronous ("TRUE")

     .FIRST_WORD_FALL_THROUGH("FALSE")          // Sets the FIFO FWFT to "TRUE" or "FALSE

  ) FIFO36_72_slice1 (

     .ALMOSTEMPTY(fifo2_almost_empty),          // 1-bit almost empty output flag

     .ALMOSTFULL(fifo2_almost_full),            // 1-bit almost full output flag

     .DBITERR(),                                // 1-bit double bit error status output

     .DO(fifo2_do),                             // 64-bit data output

     .DOP(fifo2_dop),                           // 8-bit parity data output

     .ECCPARITY(),                              // 8-bit generated error correction parity

     .EMPTY(fifo2_empty),                       // 1-bit empty output flag

     .FULL(fifo2_full),                         // 1-bit full output flag

     .RDCOUNT(),                                // 9-bit read count output

     .RDERR(fifo2_rderr),                       // 1-bit read error output

     .SBITERR(),                                // 1-bit single bit error status output

     .WRCOUNT(),                                // 9-bit write count output

     .WRERR(fifo2_wrerr),                       // 1-bit write error

     .DI(fifo2_di),                             // 64-bit data input

     .DIP(fifo2_dip),                           // 8-bit parity input

     .RDCLK(RDCLK),                             // 1-bit read clock input

     .RDEN(fifo_rden),                          // 1-bit read enable input

     .RST(RST),                                 // 1-bit reset input

     .WRCLK(WRCLK),                             // 1-bit write clock input

     .WREN(fifo_wren)                           // 1-bit write enable input

  );

  // FIFO36_72: 72x36k Synchronous/Asynchronous BlockRAM FIFO /w ECC

  //             Virtex-5

  // Xilinx HDL Libraries Guide, version 8.2.2

  FIFO36_72 #(

     .ALMOST_FULL_OFFSET(ALMOST_FULL_OFFSET),   // Sets almost full threshold

     .ALMOST_EMPTY_OFFSET(ALMOST_EMPTY_OFFSET), // Sets the almost empty threshold

     .DO_REG(DO_REG),                           // Enable output register (0 or 1)

                                                //   Must be 1 if EN_SYN = "FALSE"

     .EN_ECC_READ("FALSE"),                     // Enable ECC decoder, "TRUE" or "FALSE"

     .EN_ECC_WRITE("FALSE"),                    // Enable ECC encoder, "TRUE" or "FALSE"

     .EN_SYN(EN_SYN),                           // Specifies FIFO as Asynchronous ("FALSE")

                                                //   or Synchronous ("TRUE")

     .FIRST_WORD_FALL_THROUGH("FALSE")          // Sets the FIFO FWFT to "TRUE" or "FALSE

  ) FIFO36_72_slice2 (

     .ALMOSTEMPTY(fifo3_almost_empty),          // 1-bit almost empty output flag

     .ALMOSTFULL(fifo3_almost_full),            // 1-bit almost full output flag

     .DBITERR(),                                // 1-bit double bit error status output

     .DO(fifo3_do),                             // 64-bit data output

     .DOP(fifo3_dop),                           // 8-bit parity data output

     .ECCPARITY(),                              // 8-bit generated error correction parity

     .EMPTY(fifo3_empty),                       // 1-bit empty output flag

     .FULL(fifo3_full),                         // 1-bit full output flag

     .RDCOUNT(),                                // 9-bit read count output

     .RDERR(fifo3_rderr),                       // 1-bit read error output

     .SBITERR(),                                // 1-bit single bit error status output

     .WRCOUNT(),                                // 9-bit write count output

     .WRERR(fifo3_wrerr),                       // 1-bit write error

     .DI(fifo3_di),                             // 64-bit data input

     .DIP(fifo3_dip),                           // 8-bit parity input

     .RDCLK(RDCLK),                             // 1-bit read clock input

     .RDEN(fifo_rden),                          // 1-bit read enable input

     .RST(RST),                                 // 1-bit reset input

     .WRCLK(WRCLK),                             // 1-bit write clock input

     .WREN(fifo_wren)                           // 1-bit write enable input

  );

`ifdef CHECK_GENERATE

  initial

    $display("%m: fifo parameters: ALMOST_FULL_OFFSET=%0d ALMOST_EMPTY_OFFSET=%0d DO_REG=%0d EN_SYN=%s",

      ALMOST_FULL_OFFSET, ALMOST_EMPTY_OFFSET, DO_REG, EN_SYN);

`endif

endmodule

/* not truncated */