Subversion Repositories funbase_ip_library

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

-- Title      : UDP/IP

-- Project    : 

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

-- File       : udp_ip.vhd

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

-- Last update: 2010-08-18

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

-- Description: Receives/transmits data from/to an application, inside a UDP/IP

--              packet. Also handles ARP requests.

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

-- Revisions  :

-- Date        Version  Author  Description

-- 2009/09/03  1.0      niemin95        Created

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

library ieee;

use ieee.std_logic_1164.all;

use work.udp_ip_pkg.all;

entity udp_ip is

  generic (

    disable_rx_g  : integer := 0;

    disable_arp_g : integer := 0);

  port (

    clk               : in  std_logic;

    rst_n             : in  std_logic;

    -- to/from application

    new_tx_in         : in  std_logic;

    tx_len_in         : in  std_logic_vector( tx_len_w_c-1 downto 0 );

    target_addr_in    : in  std_logic_vector( ip_addr_w_c-1 downto 0 );

    target_port_in    : in  std_logic_vector( port_w_c-1 downto 0 );

    source_port_in    : in  std_logic_vector( port_w_c-1 downto 0 );

    tx_data_in        : in  std_logic_vector( udp_data_width_c-1 downto 0 );

    tx_data_valid_in  : in  std_logic;

    tx_re_out         : out std_logic;

    new_rx_out        : out std_logic;

    rx_data_valid_out : out std_logic;

    rx_data_out       : out std_logic_vector( udp_data_width_c-1 downto 0 );

    rx_re_in          : in  std_logic;

    rx_erroneous_out  : out std_logic;

    source_addr_out   : out std_logic_vector( ip_addr_w_c-1 downto 0 );

    source_port_out   : out std_logic_vector( port_w_c-1 downto 0 );

    dest_port_out     : out std_logic_vector( port_w_c-1 downto 0 );

    rx_len_out        : out std_logic_vector( tx_len_w_c-1 downto 0 );

    -- Use this when disable_arp_g = 1

    no_arp_target_MAC_in     : in  std_logic_vector( MAC_addr_w_c-1 downto 0 ) := (others => '0');

    -- to/from ethernet controller

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

    tx_data_valid_out : out std_logic;

    tx_re_in          : in  std_logic;

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

    new_tx_out        : out std_logic;

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

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

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

    rx_data_valid_in  : in  std_logic;

    rx_re_out         : out std_logic;

    new_rx_in         : in  std_logic;

    rx_len_in         : in  std_logic_vector( tx_len_w_c-1 downto 0 );

    rx_frame_type_in  : in  std_logic_vector( frame_type_w_c-1 downto 0 );

    rx_erroneous_in   : in  std_logic;

    rx_error_out      : out std_logic   -- this means system error, not error

                                        -- in data caused by network etc.

    );

end udp_ip;

architecture rtl of udp_ip is

  signal gen_ARP_rep              : std_logic;

  signal gen_ARP_IP               : std_logic_vector( ip_addr_w_c-1 downto 0 );

  signal IP_arpsnd_arp            : std_logic_vector( ip_addr_w_c-1 downto 0 );

  signal MAC_arp_arpsnd           : std_logic_vector( MAC_addr_w_c-1 downto 0 );

  signal ARP_entry_valid          : std_logic;

  signal MAC_request_UDP_arpsnd   : std_logic;

  signal MAC_arpsnd_UDP           : std_logic_vector( MAC_addr_w_c-1 downto 0 );

  signal MAC_valid_arpsnd_UDP     : std_logic;

  signal IP_UDP_arpsnd            : std_logic_vector( ip_addr_w_c-1 downto 0 );

  signal sending_reply_arpsnd_arp : std_logic;

  signal rx_arp_done              : std_logic;

  signal arpsnd_tx_ready          : std_logic;

  -- to and from arpsnd

  signal tx_data_from_arp       : std_logic_vector( udp_data_width_c-1 downto 0 );

  signal tx_data_valid_from_arp : std_logic;

  signal tx_re_to_arp           : std_logic;

  signal tx_target_MAC_from_arp : std_logic_vector( MAC_addr_w_c-1 downto 0 );

  signal tx_len_from_arp        : std_logic_vector( tx_len_w_c-1 downto 0 );

  signal tx_frame_type_from_arp : std_logic_vector( frame_type_w_c-1 downto 0 );

  signal new_tx_from_arp        : std_logic;

  signal rx_data_to_arp       : std_logic_vector( udp_data_width_c-1 downto 0 );

  signal rx_data_valid_to_arp : std_logic;

  signal new_rx_to_arp        : std_logic;

  signal rx_re_from_arp       : std_logic;

  -- to and from udp block

  signal tx_data_from_udp       : std_logic_vector( udp_data_width_c-1 downto 0 );

  signal tx_data_valid_from_udp : std_logic;

  signal tx_re_to_udp           : std_logic;

  signal tx_target_MAC_from_udp : std_logic_vector( MAC_addr_w_c-1 downto 0 );

  signal tx_len_from_udp        : std_logic_vector( tx_len_w_c-1 downto 0 );

  signal tx_frame_type_from_udp : std_logic_vector( frame_type_w_c-1 downto 0 );

  signal new_tx_from_udp        : std_logic;

  signal rx_data_to_udp       : std_logic_vector( udp_data_width_c-1 downto 0 );

  signal rx_data_valid_to_udp : std_logic;

  signal new_rx_to_udp        : std_logic;

  signal rx_re_from_udp       : std_logic;

  -- mux select signals

  signal input_select  : std_logic_vector( 1 downto 0 );

  signal output_select : std_logic_vector( 1 downto 0 );

  -- mux signals

  signal tx_datas       : std_logic_vector( 3*udp_data_width_c-1 downto 0 );

  signal tx_data_valids : std_logic_vector( 2 downto 0 );

  signal tx_target_MACs : std_logic_vector( 2*MAC_addr_w_c-1 downto 0 );

  signal tx_lens        : std_logic_vector( 2*tx_len_w_c-1 downto 0 );

  signal tx_frame_types : std_logic_vector( 2*frame_type_w_c-1 downto 0 );

  signal new_txs        : std_logic_vector( 1 downto 0 );

  signal tx_res         : std_logic_vector( 2 downto 0 );

  signal rx_res         : std_logic_vector( 2 downto 0 );

  signal rx_datas       : std_logic_vector( 3*udp_data_width_c-1 downto 0 );

  signal rx_data_valids : std_logic_vector( 2 downto 0 );

  signal new_rxs        : std_logic_vector( 1 downto 0 );

  signal frame_valid : std_logic;

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

begin  -- rtl

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

  --                    | Eth ctrl |

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

  --                         ||

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

  --  |UDP/IP                ||                   |

  --  |               ---------------             |

  --  |              /     MUX       \___         |

  --  |             /_________________\  |        |

  --  |              ||     ||     ||    |        |

  --  |       ----------    ||    -----------     |

  --  |       | ARPSND |----------|   UDP   |     |

  --  |       ----------    ||    -----------     |

  --  |         ||          ||       ||           |

  --  |      --------      data    addresses etc. |

  --  |      | ARP3 |        \\     //            |

  --  |      --------         \\   //             |

  --  |                        \\ //              |

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

  --                           || ||

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

  --                      | application |

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

  -- *** MUX SIGNALS ***

  -- forming the tx signals for the mux

  tx_datas       <= tx_data_in & tx_data_from_arp & tx_data_from_udp;

  tx_data_valids <= tx_data_valid_in & tx_data_valid_from_arp & tx_data_valid_from_udp;

  tx_target_MACs <= tx_target_MAC_from_arp & tx_target_MAC_from_udp;

  tx_lens        <= tx_len_from_arp & tx_len_from_udp;

  tx_frame_types <= tx_frame_type_from_arp & tx_frame_type_from_udp;

  new_txs        <= new_tx_from_arp & new_tx_from_udp;

  -- tx read enables from the mux

  tx_re_to_udp <= tx_res(0);

  tx_re_to_arp <= tx_res(1);

  tx_re_out    <= tx_res(2);

  -- rx signals

  rx_enabled: if disable_rx_g = 0 generate

    rx_res         <= rx_re_in & rx_re_from_arp & rx_re_from_udp;

    rx_data_to_udp <= rx_datas( udp_data_width_c-1 downto 0 );

    rx_data_to_arp <= rx_datas( 2*udp_data_width_c-1 downto udp_data_width_c );

    rx_data_out    <= rx_datas( 3*udp_data_width_c-1 downto 2*udp_data_width_c );

    rx_data_valid_to_udp <= rx_data_valids(0);

    rx_data_valid_to_arp <= rx_data_valids(1);

    rx_data_valid_out    <= rx_data_valids(2);

    new_rx_to_udp <= new_rxs(0);

    new_rx_to_arp <= new_rxs(1);

  end generate rx_enabled;

  -- *** /MUX SIGNALS ***

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

  -- Input/output select signals can have values from 0 to 2:

  -- 0: UDP

  -- 1: ARP

  -- 2: application

  data_mux : entity work.udp_arp_data_mux

    generic map (

      data_width_g       => udp_data_width_c,

      tx_len_w_g         => tx_len_w_c

      )

    port map (

      rx_data_valid_in   => rx_data_valid_in,

      new_rx_in          => new_rx_in,

      rx_data_in         => rx_data_in,

      rx_res_in          => rx_res,

      rx_re_out          => rx_re_out,

      rx_datas_out       => rx_datas,

      rx_data_valids_out => rx_data_valids,

      new_rxs_out        => new_rxs,

      tx_datas_in        => tx_datas,

      tx_data_valids_in  => tx_data_valids,

      tx_target_MACs_in  => tx_target_MACs,

      tx_lens_in         => tx_lens,

      tx_frame_types_in  => tx_frame_types,

      new_txs_in         => new_txs,

      tx_re_in           => tx_re_in,

      tx_data_out        => tx_data_out,

      tx_data_valid_out  => tx_data_valid_out,

      tx_target_MAC_out  => target_MAC_out,

      tx_len_out         => tx_len_out,

      tx_frame_type_out  => tx_frame_type_out,

      new_tx_out         => new_tx_out,

      tx_res_out         => tx_res,

      input_select_in    => input_select,

      output_select_in   => output_select

      );

  frame_valid <= not rx_erroneous_in;

  arp_enabled: if disable_arp_g = 0 generate

    arp_block : entity work.ARP

      port map (

        clk               => clk,

        rstn              => rst_n,

        new_frame_in      => new_rx_to_arp,

        new_word_valid_in => rx_data_valid_to_arp,

        frame_re_out      => rx_re_from_arp,

        frame_data_in     => rx_data_to_arp,

        frame_valid_in    => frame_valid,

        frame_len_in      => rx_len_in,

        sending_reply_in  => sending_reply_arpsnd_arp,

        req_IP_in         => IP_arpsnd_arp,

        gen_ARP_rep_out   => gen_ARP_rep,

        gen_ARP_IP_out    => gen_ARP_IP,

        lookup_MAC_out    => MAC_arp_arpsnd,

        valid_entry_out   => ARP_entry_valid,

        done_out          => rx_arp_done

        );

    arpsend : entity work.ARPSnd

      port map (

        clk                => clk,

        rstn               => rst_n,

        request_MAC_in     => MAC_request_UDP_arpsnd,

        targer_IP_in       => IP_UDP_arpsnd,

        ARP_entry_valid_in => ARP_entry_valid,

        gen_ARP_reply_in   => gen_ARP_rep,

        gen_ARP_IP_in      => gen_ARP_IP,

        lookup_MAC_in      => MAC_arp_arpsnd,

        lookup_IP_out      => IP_arpsnd_arp,

        sending_reply_out  => sending_reply_arpsnd_arp,

        target_MAC_out     => tx_target_MAC_from_arp,

        requested_MAC_out  => MAC_arpsnd_UDP,

        req_MAC_valid_out  => MAC_valid_arpsnd_UDP,

        gen_frame_out      => new_tx_from_arp,

        frame_type_out     => tx_frame_type_from_arp,

        frame_size_out     => tx_len_from_arp,

        tx_ready_out       => arpsnd_tx_ready,

        wr_data_valid_out  => tx_data_valid_from_arp,

        wr_data_out        => tx_data_from_arp,

        wr_re_in           => tx_re_to_arp

        );

  end generate arp_enabled;

  arp_disabled: if disable_arp_g = 1 generate

    MAC_arpsnd_UDP       <= no_arp_target_MAC_in;

    MAC_valid_arpsnd_UDP <= '1';

    new_tx_from_arp      <= '0';

    arpsnd_tx_ready      <= '1';

  end generate arp_disabled;

  udp_block: entity work.udp

    generic map (

        data_width_g => udp_data_width_c,

        tx_len_w_g   => tx_len_w_c

        )

    port map (

        clk                   => clk,

        rst_n                 => rst_n,

        new_tx_in             => new_tx_in,

        tx_len_in             => tx_len_in,

        target_IP_in          => target_addr_in,

        target_port_in        => target_port_in,

        source_port_in        => source_port_in,

        new_tx_out            => new_tx_from_udp,

        tx_MAC_addr_out       => tx_target_MAC_from_udp,

        tx_len_out            => tx_len_from_udp,

        tx_frame_type_out     => tx_frame_type_from_udp,

        header_data_out       => tx_data_from_udp,

        header_data_valid_out => tx_data_valid_from_udp,

        ethernet_re_in        => tx_re_in,

        new_rx_in             => new_rx_to_udp,

        rx_data_in            => rx_data_to_udp,

        rx_data_valid_in      => rx_data_valid_to_udp,

        rx_len_in             => rx_len_in,

        rx_frame_type_in      => rx_frame_type_in,

        rx_re_out             => rx_re_from_udp,

        rx_erroneous_in       => rx_erroneous_in,

        rx_erroneous_out      => rx_erroneous_out,

        new_rx_out            => new_rx_out,

        rx_len_out            => rx_len_out,

        source_IP_out         => source_addr_out,

        source_port_out       => source_port_out,

        dest_port_out         => dest_port_out,

        application_re_in     => rx_re_in,

        request_MAC_out       => MAC_request_UDP_arpsnd,

        IP_to_arp_out         => IP_UDP_arpsnd,

        requested_MAC_in      => MAC_arpsnd_UDP,

        req_MAC_valid_in      => MAC_valid_arpsnd_UDP,

        rx_arp_ready_in       => rx_arp_done,

        snd_req_from_arp_in   => new_tx_from_arp,

        tx_arp_ready_in       => arpsnd_tx_ready,

        rx_error_out          => rx_error_out,

        input_select_out      => input_select,

        output_select_out     => output_select

        );

end rtl;