Subversion Repositories funbase_ip_library

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

-- Title      : data mux

-- Project    : 

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

-- File       : udp_arp_data_mux.vhd

-- Author     : Jussi Nieminen  <niemin95@galapagosinkeiju.cs.tut.fi>

-- Last update: 2010-08-18

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

-- Description: Multiplexer.

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

-- Revisions  :

-- Date        Version  Author  Description

-- 2009/09/15  1.0      niemin95        Created

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

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

use work.udp_ip_pkg.all;

entity udp_arp_data_mux is

  generic (

    data_width_g : integer := 16;

    tx_len_w_g   : integer := 11

    );

  port (

    rx_data_valid_in   : in  std_logic;

    new_rx_in          : in  std_logic;

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

    rx_res_in          : in  std_logic_vector( 2 downto 0 );

    rx_re_out          : out std_logic;

    rx_datas_out       : out std_logic_vector( 3*data_width_g-1 downto 0 );

    rx_data_valids_out : out std_logic_vector( 2 downto 0 );

    new_rxs_out        : out std_logic_vector( 1 downto 0 );

    tx_datas_in        : in  std_logic_vector( 3*data_width_g-1 downto 0 );

    tx_data_valids_in  : in  std_logic_vector( 2 downto 0 );

    tx_target_MACs_in  : in  std_logic_vector( 2*MAC_addr_w_c-1 downto 0 );

    tx_lens_in         : in  std_logic_vector( 2*tx_len_w_g-1 downto 0 );

    tx_frame_types_in  : in  std_logic_vector( 2*frame_type_w_c-1 downto 0 );

    new_txs_in         : in  std_logic_vector( 1 downto 0 );

    tx_re_in           : in  std_logic;

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

    tx_data_valid_out  : out std_logic;

    tx_target_MAC_out  : out std_logic_vector( MAC_addr_w_c-1 downto 0 );

    tx_len_out         : out std_logic_vector( tx_len_w_g-1 downto 0 );

    tx_frame_type_out  : out std_logic_vector( frame_type_w_c-1 downto 0 );

    new_tx_out         : out std_logic;

    tx_res_out         : out std_logic_vector( 2 downto 0 );

    input_select_in    : in  std_logic_vector( 1 downto 0 );

    output_select_in   : in  std_logic_vector( 1 downto 0 )

    );

end udp_arp_data_mux;

architecture rtl of udp_arp_data_mux is

  signal input_select_int  : integer range 0 to 2;

  signal output_select_int : integer range 0 to 2;

  type tx_data_array is array (0 to 2) of std_logic_vector( udp_data_width_c-1 downto 0 );

  signal rx_datas_array_r : tx_data_array;

  signal tx_datas_array_r : tx_data_array;

  type MAC_array is array (0 to 1) of std_logic_vector( MAC_addr_w_c-1 downto 0 );

  signal MAC_addr_array_r : MAC_array;

  type frame_type_array is array (0 to 1) of std_logic_vector( frame_type_w_c-1 downto 0 );

  signal frame_type_array_r : frame_type_array;

  type tx_lens_array is array (0 to 1) of std_logic_vector( tx_len_w_c-1 downto 0 );

  signal tx_lens_array_r : tx_lens_array;

  constant udp_selected_c : integer := 0;

  constant arp_selected_c : integer := 1;

  constant app_selected_c : integer := 2;

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

begin  -- rtl

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

  input_select_int  <= to_integer( unsigned( input_select_in ));

  output_select_int <= to_integer( unsigned( output_select_in ));

  -- 0: UDP

  -- 1: ARP

  -- 2: application

  datas: for n in 0 to 2 generate

    rx_datas_out( (n+1)*udp_data_width_c-1 downto n*udp_data_width_c ) <= rx_datas_array_r(n);

    tx_datas_array_r(n) <= tx_datas_in( (n+1)*udp_data_width_c-1 downto n*udp_data_width_c );

  end generate datas;

  other_arrays: for n in 0 to 1 generate

    MAC_addr_array_r(n)   <= tx_target_MACs_in( (n+1)*MAC_addr_w_c-1 downto n*MAC_addr_w_c );

    frame_type_array_r(n) <= tx_frame_types_in( (n+1)*frame_type_w_c-1 downto n*frame_type_w_c );

    tx_lens_array_r(n)    <= tx_lens_in( (n+1)*tx_len_w_c-1 downto n*tx_len_w_c );

  end generate other_arrays;

  eth_data_mux : process (rx_data_in, rx_data_valid_in, new_rx_in, input_select_int,

                          output_select_int, rx_res_in, tx_datas_array_r, tx_data_valids_in,

                          MAC_addr_array_r, tx_lens_array_r, frame_type_array_r, new_txs_in,

                          tx_re_in)

  begin  -- process eth_data_mux

    -- ** INPUTS **

    -- default values. Others than the selected range stay as zero.

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

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

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

    rx_datas_array_r(input_select_int) <= rx_data_in;

    rx_data_valids_out( input_select_int ) <= rx_data_valid_in;

    if input_select_int /= app_selected_c then

      new_rxs_out( input_select_int ) <= new_rx_in;

    else

      -- if data is going to application, also the udp block needs to have the

      -- data_valid signal (to know when reading really happens. Plain re from

      -- application isn't enough, cause it can be up even if data_valid is down.)

      rx_data_valids_out(udp_selected_c) <= rx_data_valid_in;

    end if;

    rx_re_out <= rx_res_in( input_select_int );

    -- ** OUTPUTS **

    tx_data_out         <= tx_datas_array_r( output_select_int );

    tx_data_valid_out   <= tx_data_valids_in( output_select_int );

    -- only data and data_valid can come from application, others come either

    -- from arp or udp

    if output_select_int /= app_selected_c then

      tx_target_MAC_out <= MAC_addr_array_r( output_select_int );

      tx_len_out        <= tx_lens_array_r( output_select_int );

      tx_frame_type_out <= frame_type_array_r( output_select_int );

      new_tx_out        <= new_txs_in( output_select_int );

    else

      -- if data is coming from the application, these signals have been set by

      -- udp block

      tx_target_MAC_out <= MAC_addr_array_r( udp_selected_c );

      tx_len_out        <= tx_lens_array_r( udp_selected_c );

      tx_frame_type_out <= frame_type_array_r( udp_selected_c );

      new_tx_out        <= new_txs_in( udp_selected_c );

    end if;

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

    tx_res_out( output_select_int ) <= tx_re_in;

  end process eth_data_mux;

end rtl;