Subversion Repositories funbase_ip_library

-------------------------------------------------------------------------------

-- Title      : fifo

-- Project    : 

-------------------------------------------------------------------------------

-- File       : fifo_ram_dynamic.vhd

-- Author     : 

-- Company    : 

-- Created    : 2005-05-26

-- Last update: 2006-03-02

-- Platform   : 

-- Standard   : VHDL'87

-------------------------------------------------------------------------------

-- Description: Fifo w/dynamic depth implemented with dual port RAM

-------------------------------------------------------------------------------

-- Copyright (c) 2005 

-------------------------------------------------------------------------------

-- Revisions  :

-- Date        Version  Author  Description

-- 2005-05-26  1.0      penttin5        Created

-------------------------------------------------------------------------------

--

-- NOTE! generic depth_g is the maximum depth of fifo

-- NOTE! Precision RTL synthesisis 2004c.45 doesn't infer the RAM with

--       asynchronous read for Stratix 1 S40F780C5.

--       Quartus II 4.2 infers RAM with asynchronic read but gives old RAM

--       value when reading and writing simultaneusly to/from same address.

--       That doesn't matter because FIFO doesn't read and write in the same

--       address at the same time.

--

-------------------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_arith.all;

use ieee.std_logic_unsigned.all;

entity fifo is

  generic (

    data_width_g : integer := 32;

    depth_g      : integer := 10        -- this is the maximum depth of fifo!

    );

  port (

    clk       : in  std_logic;

    rst_n     : in  std_logic;

    data_in   : in  std_logic_vector (data_width_g-1 downto 0);

    we_in     : in  std_logic;

    one_p_out : out std_logic;

    full_out  : out std_logic;

    data_out  : out std_logic_vector (data_width_g-1 downto 0);

    re_in     : in  std_logic;

    empty_out : out std_logic;

    one_d_out : out std_logic

    );

end fifo;

architecture rtl of fifo is

  -- this is the configuration RAM which holds the

  -- dynamic depth value at address 0

  component conf_ram

    port (

      address : in  std_logic_vector(3 downto 0);

      clock   : in  std_logic;

      q       : out std_logic_vector(7 downto 0)

      );

  end component;

  component dual_ram_async_read

    generic (

      ram_width : integer := 0;

      ram_depth : integer := 0);

    port

      (

        clock1        : in  std_logic;

        clock2        : in  std_logic;

        data          : in  std_logic_vector(0 to ram_width - 1);

        write_address : in  integer range 0 to ram_depth - 1;

        read_address  : in  integer range 0 to ram_depth - 1;

        we            : in  std_logic;

        q             : out std_logic_vector(0 to ram_width - 1)

        );

  end component;  -- dual_ram_async_read

  signal write_address_r    : integer range 0 to depth_g - 1;

  signal read_address_r     : integer range 0 to depth_g - 1;

  signal write_read_count_r : integer range 0 to depth_g;

  signal ram_data_out_i     : std_logic_vector(0 to data_width_g - 1);

  signal we_ram             : std_logic;

  signal conf_ram_addr       : std_logic_vector(3 downto 0);

  signal depth_from_conf_ram : std_logic_vector(7 downto 0);

  signal dynamic_depth_r     : integer range 0 to depth_g;

  signal full_out_r          : std_logic;

begin  -- rtl

  conf_ram_inst : conf_ram

    port map (

      address => (others => '0'),

      clock   => clk,

      q       => depth_from_conf_ram

      );

  gen_dual_ram : dual_ram_async_read

    generic map (

      ram_width => data_width_g,

      ram_depth => depth_g

      )

    port map (

      clock1        => clk,

      clock2        => clk,

      data          => data_in,

      write_address => write_address_r,

      read_address  => read_address_r,

      we            => we_ram,

      q             => ram_data_out_i

      );

  full_out <= full_out_r;

  -- write to fifo when write enabled and fifo not full

  we_ram <= we_in when full_out_r = '0'--write_read_count_r < dynamic_depth_r

            else '0';

  data_out <= ram_data_out_i;

--  one_d_out <= '1' when write_read_count_r = 1 else

--               '0';

--  one_p_out <= '1' when write_read_count_r = dynamic_depth_r - 1 else

--               '0';

--  empty_out <= '1' when write_read_count_r = 0 else

--               '0';

--  full_out <= '1' when write_read_count_r >= dynamic_depth_r else

--              '0';

  update_flags: process (clk, rst_n)

  begin  -- process update_flags

    if rst_n = '0' then                 -- asynchronous reset (active low)

      one_d_out <= '0';

      one_p_out <= '0';

      empty_out <= '1';

      full_out_r  <= '0';

    elsif clk'event and clk = '1' then  -- rising clock edge

      if (we_in = '0' and re_in = '0' and write_read_count_r = 1) or

        (we_in = '1' and re_in = '1' and write_read_count_r = 1) or

        (we_in = '1' and re_in = '0' and write_read_count_r = 0) or

        (we_in = '0' and re_in = '1' and write_read_count_r = 2) then

        one_d_out <= '1';

      else

        one_d_out <= '0';

      end if;

      if (we_in = '0' and re_in = '0' and write_read_count_r = dynamic_depth_r - 1) or

        (we_in = '1' and re_in = '1' and write_read_count_r = dynamic_depth_r - 1) or

        (we_in = '1' and re_in = '0' and write_read_count_r = dynamic_depth_r - 2) or

        (we_in = '0' and re_in = '1' and write_read_count_r = dynamic_depth_r) then

        one_p_out <= '1';

      else

        one_p_out <= '0';

      end if;

      if (we_in = '0' and re_in = '0' and write_read_count_r = 0) or

        (we_in = '0' and re_in = '1' and write_read_count_r = 0) or

        (we_in = '0' and re_in = '1' and write_read_count_r = 1) then

        empty_out <= '1';

      else

        empty_out <= '0';

      end if;

      if (we_in = '0' and re_in = '0' and write_read_count_r = dynamic_depth_r) or

        (we_in = '1' and re_in = '0' and write_read_count_r = dynamic_depth_r) or

        (we_in = '1' and re_in = '0' and write_read_count_r = dynamic_depth_r - 1) or

        (write_read_count_r > dynamic_depth_r) then

        full_out_r <= '1';

      else

        full_out_r <= '0';

      end if;

    end if;

  end process update_flags;

  -----------------------------------------------------------------------------

  -- Update dynamic depth

  -----------------------------------------------------------------------------

  update_dynamic_depth_r : process (clk, rst_n)

  begin  -- process update_dynamic_depth_r

    if rst_n = '0' then                 -- asynchronous reset (active low)

      dynamic_depth_r <= depth_g;

      conf_ram_addr   <= (others => '0');

    elsif clk'event and clk = '1' then  -- rising clock edge

      conf_ram_addr <= (others => '0');

      if conv_integer(depth_from_conf_ram) > depth_g

        or depth_from_conf_ram =

        -- dynamic depth is bigger than maximum depth or

        -- it's not defined(zero) => Use the maximum depth

        conv_std_logic_vector(0, depth_from_conf_ram'length) then

        dynamic_depth_r <= depth_g;

      else

        -- update dynamic depth

        dynamic_depth_r <=

          conv_integer(depth_from_conf_ram);

      end if;

    end if;

  end process update_dynamic_depth_r;

  -----------------------------------------------------------------------------

  -- Update read and write addresses

  -----------------------------------------------------------------------------

  fifo_read_and_write : process (clk, rst_n)

  begin  -- process fifo_read_and_write

    if rst_n = '0' then                 -- asynchronous reset (active low)

      write_read_count_r <= 0;

      read_address_r     <= 0;

      write_address_r    <= 0;

    elsif clk'event and clk = '1' then  -- rising clock edge

      -- read if re_in = '1' and fifo not empty or

      --         simultaneus read and write and fifo full

      if re_in = '1' and ((we_in = '0' and write_read_count_r /= 0)

                          or (we_in = '1'

                              and write_read_count_r = dynamic_depth_r)) then

        write_read_count_r <= write_read_count_r - 1;

        if read_address_r = dynamic_depth_r - 1 then

          read_address_r <= 0;

        else

          read_address_r <= read_address_r + 1;

        end if;

        write_address_r <= write_address_r;

        -- write if we_in = '1' and fifo not full or

        --          simultaneus read and write and fifo empty

      elsif we_in = '1' and ((re_in = '0' and

                              write_read_count_r /= dynamic_depth_r)

                             or (re_in = '1' and write_read_count_r = 0)) then

        write_read_count_r <= write_read_count_r + 1;

        read_address_r     <= read_address_r;

        if write_address_r = dynamic_depth_r - 1 then

          write_address_r <= 0;

        else

          write_address_r <= write_address_r + 1;

        end if;

        -- write and read at the same time if re_in = '1' and we_in = '1' and

        -- fifo not empty or full

      elsif re_in = '1' and we_in = '1'

        and write_read_count_r /= dynamic_depth_r

        and write_read_count_r /= 0 then

        write_read_count_r <= write_read_count_r;

        if read_address_r = dynamic_depth_r - 1 then

          read_address_r <= 0;

        else

          read_address_r <= read_address_r + 1;

        end if;

        if write_address_r = dynamic_depth_r - 1 then

          write_address_r <= 0;

        else

          write_address_r <= write_address_r + 1;

        end if;

      else

        write_read_count_r <= write_read_count_r;

        read_address_r     <= read_address_r;

        write_address_r    <= write_address_r;

      end if;

    end if;

  end process fifo_read_and_write;

end rtl;