Subversion Repositories funbase_ip_library

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

-- Title      : UDP/IP header handling

-- Project    : 

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

-- File       : udp.vhd

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

-- Company    : 

-- Last update: 2010/01/06

-- Platform   : 

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

-- Description: Adds and removes UDP and IP headers to data

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

-- Revisions  :

-- Date        Version  Author  Description

-- 2009/09/16  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 is

  generic (

    data_width_g : integer := 16;

    tx_len_w_g   : integer := 11);

  port (

    clk                   : in  std_logic;

    rst_n                 : in  std_logic;

    -- from application to udp

    new_tx_in             : in  std_logic;

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

    target_IP_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 );

    -- from udp to eth

    new_tx_out            : out std_logic;

    tx_MAC_addr_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 );

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

    header_data_valid_out : out std_logic;

    ethernet_re_in        : in  std_logic;

    new_rx_in             : in  std_logic;

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

    rx_data_valid_in      : in  std_logic;

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

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

    rx_re_out             : out std_logic;

    rx_erroneous_in       : in  std_logic;

    -- from udp to application

    rx_erroneous_out      : out std_logic;

    new_rx_out            : out std_logic;

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

    source_IP_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 );

    application_re_in     : in  std_logic;

    -- from udp to arpsnd

    request_MAC_out       : out std_logic;

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

    requested_MAC_in      : in  std_logic_vector( MAC_addr_w_c-1 downto 0 );

    req_MAC_valid_in      : in  std_logic;

    rx_arp_ready_in       : in  std_logic;

    snd_req_from_arp_in   : in  std_logic;

    tx_arp_ready_in       : in  std_logic;

    -- other control signals

    rx_error_out          : out std_logic;

    input_select_out      : out std_logic_vector( 1 downto 0 );

    output_select_out     : out std_logic_vector( 1 downto 0 )

    );

end udp;

architecture rtl of udp is

  type tx_state_type is (tx_idle, write_IP_headers, write_UDP_headers, relay_tx_data, tx_arp);

  type rx_state_type is (rx_idle, read_IP_headers, read_UDP_headers, relay_rx_data,

                         rx_arp, rx_discard, rx_error);

  type IP_header_state_type is (version_IHL_DS, IP_length, ID, flags_offset, TTL_protocol,

                                header_checksum, source_addr1, source_addr2,

                                dest_addr1, dest_addr2, discard);

  type UDP_header_state_type is (source_port, dest_port, UDP_length, UDP_checksum);

  signal rx_state_r     : rx_state_type;

  signal tx_state_r     : tx_state_type;

  signal tx_IP_state_r  : IP_header_state_type;

  signal tx_UDP_state_r : UDP_header_state_type;

  signal rx_IP_state_r  : IP_header_state_type;

  signal rx_UDP_state_r : UDP_header_state_type;

  signal rx_len_r        : integer range 0 to 2**tx_len_w_g-1;

  signal rx_re_r         : std_logic;

  signal discard_rx_r : std_logic;

  signal tx_len_r      : integer range 0 to 2**tx_len_w_g-1;

  signal target_port_r : std_logic_vector( port_w_c-1 downto 0 );

  signal source_port_r : std_logic_vector( port_w_c-1 downto 0 );

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

  signal ip_checksum : std_logic_vector( ip_checksum_w_c-1 downto 0 );

  signal discard_xtra_bytes_r : std_logic;

  signal num_xtra_bytes_r : integer range 0 to 63;

  constant IP_header_words_c : integer := 5;  -- 32bit words

  constant UDP_header_length_c : integer := 8;  -- bytes

  -- precounted part of IP checksum, including field version_IHL_DS, ID,

  -- flags_offset and TTL_protocol

  constant pre_counted_part_of_checksum_c : std_logic_vector( ip_checksum_w_c-1 downto 0 )

    := "0100101000010001";

  signal tx_len_for_checksum : std_logic_vector( 15 downto 0 );

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

begin  -- rtl

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

  -- *********************************************************************************

  -- REMEMBER!! rx_data_in(15 downto 8) = LSByte and rx_data_in(7 downto 0) = MSByte!!

  -- Same goes for the tx_data_out too!

  -- *********************************************************************************

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

  rx_re_out <= rx_re_r;

  rx_process : process (clk, rst_n)

    variable incoming_len_v : integer range 0 to 2**tx_len_w_g-1;

  begin  -- process rx_process

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

      rx_state_r <= rx_idle;

      rx_IP_state_r <= version_IHL_DS;

      rx_UDP_state_r <= source_port;

      rx_re_r               <= '0';

      rx_erroneous_out      <= '0';

      new_rx_out            <= '0';

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

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

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

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

      discard_rx_r          <= '0';

      discard_xtra_bytes_r  <= '0';

      num_xtra_bytes_r      <= 0;

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

      rx_error_out <= '0';

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

      case rx_state_r is

        when rx_idle =>

          new_rx_out       <= '0';

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

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

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

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

          rx_erroneous_out <= '0';

          discard_rx_r         <= '0';

          discard_xtra_bytes_r <= '0';

          num_xtra_bytes_r     <= 0;

          if new_rx_in = '1' then

            if rx_frame_type_in = ARP_frame_type_c then

              -- arp packet goes straight to arp

              rx_state_r <= rx_arp;

            elsif rx_frame_type_in = IP_frame_type_c then

              -- data transfer coming, start reading the headers

              rx_state_r <= read_IP_headers;

              rx_IP_state_r <= version_IHL_DS;

              rx_len_r <= to_integer( unsigned( rx_len_in ));

              rx_erroneous_out <= rx_erroneous_in;

            else

              -- whoaa, unknown protocol, discard

              rx_len_r <= to_integer( unsigned( rx_len_in ));

              rx_state_r <= rx_discard;

            end if;

          end if;

        when read_IP_headers =>

          if rx_data_valid_in = '1' and rx_re_r = '0' then

            rx_re_r <= '1';

          end if;

          if rx_data_valid_in = '1' and rx_re_r = '1' then

            rx_re_r <= '0';

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

            -- sub FSM handling the different fields of tx

            case rx_IP_state_r is

              when version_IHL_DS =>

                -- 0_____________4_______________8_________________________16

                -- |   version   | header length | Differentiated Services |

                -- only thing we are interested of is the header length

                -- if there's options-fields (over 5 32bit words in the header)

                -- we simply discard this transmission

                if to_integer( unsigned( rx_data_in(3 downto 0) )) /= IP_header_words_c then

                  discard_rx_r <= '1';

                end if;

                rx_IP_state_r <= IP_length;

              when IP_length =>

                -- total length of the packet, including header and the data.

                incoming_len_v := to_integer( unsigned( rx_data_in(7 downto 0 ) & rx_data_in( 15 downto 8 ) ));

                -- +1, because when reading two bytes at a time, we don't need

                -- to read any xtra if rx_len = incoming_len_v + 1

                if rx_len_r > incoming_len_v + 1 then

                  -- amount of data is less than ethernet minimum frame size (64 bytes)

                  -- we have to discard the extra bytes after data has been relayed.

                  discard_xtra_bytes_r <= '1';

                  -- getting rid of the last bit, because with odd lengths one

                  -- of the xtra bytes is already read out with the last databyte

                  num_xtra_bytes_r <= (( rx_len_r - incoming_len_v ) / 2 ) * 2;

                elsif rx_len_r /= incoming_len_v and rx_len_r /= incoming_len_v + 1 then

                  -- there's something wrong

                  rx_state_r <= rx_error;

                end if;

                rx_len_r <= incoming_len_v;

                rx_IP_state_r <= ID;

              when ID =>

                -- we don't care about this field

                rx_IP_state_r <= flags_offset;

              when flags_offset =>

                -- we don't care about the flags or the offset either

                rx_IP_state_r <= TTL_protocol;

              when TTL_protocol =>

                -- 0______________8______________16

                -- | Time To Live |   Protocol   |

                -- check that the protocol is UDP and TTL /= 0,

                -- otherwise discard this transmission

                if to_integer( unsigned( rx_data_in( 7 downto 0 ) )) = 0 or

                  rx_data_in( 15 downto 8 ) /= UDP_protocol_c

                then

                  discard_rx_r <= '1';

                end if;

                rx_IP_state_r <= header_checksum;

              when header_checksum =>

                -- checksum check not implemented yet, maybe some day...

                rx_IP_state_r <= source_addr1;

              when source_addr1 =>

                source_IP_out( 31 downto 24 ) <= rx_data_in( 7 downto 0 );

                source_IP_out( 23 downto 16 ) <= rx_data_in( 15 downto 8 );

                rx_IP_state_r <= source_addr2;

              when source_addr2 =>

                source_IP_out( 15 downto 8 ) <= rx_data_in( 7 downto 0 );

                source_IP_out( 7 downto 0 )  <= rx_data_in( 15 downto 8 );

                rx_IP_state_r <= dest_addr1;

              when dest_addr1 =>

                -- just check that the addr matches

                if rx_data_in( 7 downto 0 ) /= own_ip_c( 31 downto 24 ) or

                  rx_data_in( 15 downto 8 ) /= own_ip_c( 23 downto 16 )

                then

                  -- some multicast messages contain a certain IP, so we might

                  -- get packets with wrong address

                  discard_rx_r <= '1';

                end if;

                rx_IP_state_r <= dest_addr2;

              when dest_addr2 =>

                if (rx_data_in( 7 downto 0 ) /= own_ip_c( 15 downto 8 ) or

                  rx_data_in( 15 downto 8 ) /= own_ip_c( 7 downto 0 ))

                  or discard_rx_r = '1'

                then

                  -- if message is to be discarded, go and discard it, otherwise

                  -- start reading UDP headers

                  rx_IP_state_r <= discard;

                  -- there might also be extra bytes to discard, so add them to

                  -- the length and remove IP header length

                  rx_len_r <= rx_len_r + num_xtra_bytes_r - ( IP_header_words_c*4 );

                else

                  rx_state_r     <= read_UDP_headers;

                  rx_UDP_state_r <= source_port;

                  rx_IP_state_r  <= version_IHL_DS;

                  -- remove IP header length

                  rx_len_r <= rx_len_r - ( IP_header_words_c * 4 );

                end if;

              when discard =>

                -- just pretend to be reading

                if rx_len_r <= 2 then

                  -- all done

                  rx_len_r <= 0;

                  rx_IP_state_r <= version_IHL_DS;

                  rx_state_r <= rx_idle;

                else

                  rx_len_r <= rx_len_r - 2;

                end if;

              when others => null;

            end case;

            -- /rx_IP_state_r

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

          end if;

        when read_UDP_headers =>

          if rx_data_valid_in = '1' and rx_re_r = '0' then

            rx_re_r <= '1';

          end if;

          if rx_data_valid_in = '1' and rx_re_r = '1' then

            rx_re_r <= '0';

            -- FSM to read the UDP header

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

            case rx_UDP_state_r is

              when source_port =>

                source_port_out( 15 downto 8 ) <= rx_data_in( 7 downto 0 );

                source_port_out( 7 downto 0 )  <= rx_data_in( 15 downto 8 );

                rx_UDP_state_r <= dest_port;

              when dest_port =>

                dest_port_out( 15 downto 8 ) <= rx_data_in( 7 downto 0 );

                dest_port_out( 7 downto 0 )  <= rx_data_in( 15 downto 8 );

                rx_UDP_state_r <= UDP_length;

              when UDP_length =>

                -- check that the length field is correct

                if rx_len_r /=

                  to_integer( unsigned( rx_data_in(7 downto 0 ) & rx_data_in( 15 downto 8 ) ))

                then

                  rx_state_r <= rx_error;

                end if;

                rx_UDP_state_r <= UDP_checksum;

              when UDP_checksum =>

                -- umm, it's propably correct...

                -- give rx_data to application

                input_select_out <= "10";

                rx_state_r <= relay_rx_data;

                -- notify application about new tx

                new_rx_out <= '1';

                rx_len_out <= std_logic_vector( to_unsigned( rx_len_r -

                                                             UDP_header_length_c,

                                                             tx_len_w_g ));

                rx_UDP_state_r <= source_port;

                rx_len_r <= rx_len_r - UDP_header_length_c;

              when others => null;

            end case;

            -- /rx_UDP_state_r

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

          end if;

        when relay_rx_data =>

          -- monitor application_re

          if application_re_in = '1' and rx_data_valid_in = '1' then

            new_rx_out <= '0';

            if rx_len_r <= 2 then

              -- all received

              input_select_out <= "00";

              -- if there is extra bytes

              if discard_xtra_bytes_r = '1' then

                rx_state_r           <= rx_discard;

                rx_len_r             <= num_xtra_bytes_r;

                discard_xtra_bytes_r <= '0';

                num_xtra_bytes_r     <= 0;

              else

                rx_state_r <= rx_idle;

                rx_len_r   <= 0;

              end if;

            else

              rx_len_r <= rx_len_r - 2;

            end if;

          end if;

        when rx_arp =>

          -- give turn to arp until it says it's ready

          input_select_out <= "01";

          if rx_arp_ready_in = '1' then

            input_select_out <= "00";

            rx_state_r <= rx_idle;

          end if;

        when rx_discard =>

          -- we come here, if the frame type of ethernet frame is something

          -- else than ARP or IP or if there is extra bytes in the frame (less

          -- data than minimum ethernet frame size)

          if rx_data_valid_in = '1' and rx_re_r = '0' then

            rx_re_r <= '1';

          end if;

          if rx_data_valid_in = '1' and rx_re_r = '1' then

            rx_re_r <= '0';

            -- just pretend to be reading

            if rx_len_r <= 2 then

              -- all done

              rx_len_r <= 0;

              rx_state_r <= rx_idle;

            else

              rx_len_r <= rx_len_r - 2;

            end if;

          end if;

        when rx_error =>

          -- shit just hit the fan

          rx_error_out <= '1';

        when others => null;

      end case;

    end if;

  end process rx_process;

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

  tx_len_for_checksum <= std_logic_vector( to_unsigned( tx_len_r, 16 ));

  -- IP checksum computation

  checksum_adder: entity work.ip_checksum

    generic map (

        pre_counted_part_g => pre_counted_part_of_checksum_c

        )

    port map (

        total_length_field_in => tx_len_for_checksum,

        source_addr_field_in  => own_ip_c,

        dest_addr_field_in    => target_addr_r,

        header_checksum_out   => ip_checksum

        );

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

  tx_process: process (clk, rst_n)

    variable tx_len_v : integer range 0 to 2**tx_len_w_g-1;

    variable tx_len_slv_v : std_logic_vector( 15 downto 0 );

  begin  -- process tx_process

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

      tx_state_r <= tx_idle;

      tx_IP_state_r <= version_IHL_DS;

      tx_UDP_state_r <= source_port;

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

      tx_len_r <= 0;

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

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

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

      request_MAC_out       <= '0';

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

      new_tx_out            <= '0';

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

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

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

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

      header_data_valid_out <= '0';

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

      case tx_state_r is

        when tx_idle =>

          -- if arp want's to send, give it the output

          if snd_req_from_arp_in = '1' then

            tx_state_r <= tx_arp;

          elsif new_tx_in = '1' then

            if req_MAC_valid_in = '1' then

              -- MAC found from the ARP table, start sending

              tx_state_r <= write_IP_headers;

              -- write first word here already (version_IHL_DS)

              -- first the version, IPv4

              header_data_out( 7 downto 4 ) <= "0100";

              -- then header length in words

              header_data_out( 3 downto 0 ) <= std_logic_vector( to_unsigned( IP_header_words_c, 4 ));

              -- then Differentiated Services (just zeros)

              header_data_out( 15 downto 8 ) <= (others => '0');

              header_data_valid_out <= '1';

              tx_len_v   := to_integer( unsigned( tx_len_in )) +

                            IP_header_words_c*4 + UDP_header_length_c;

              tx_len_r   <= tx_len_v;

              tx_len_out <= std_logic_vector( to_unsigned( tx_len_v, tx_len_w_g ));

              new_tx_out <= '1';

              tx_frame_type_out <= IP_frame_type_c;

              source_port_r    <= source_port_in;

              target_port_r    <= target_port_in;

              target_addr_r    <= target_IP_in;

              tx_MAC_addr_out  <= requested_MAC_in;

              request_MAC_out <= '0';

            else

              -- We must get the MAC address before we can start sending

              request_MAC_out <= '1';

              IP_to_arp_out   <= target_IP_in;

            end if;

          end if;

        when write_IP_headers =>

          if ethernet_re_in = '1' then

            -- the data of the next state is written during the previous one

            case tx_IP_state_r is

              when version_IHL_DS =>

                new_tx_out <= '0';

                tx_IP_state_r <= IP_length;

                -- remember, data goes in as 2 bytes, not as single 16-bit word

                tx_len_slv_v := std_logic_vector( to_unsigned( tx_len_r, 16 ));

                header_data_out <= tx_len_slv_v( 7 downto 0 ) & tx_len_slv_v( 15 downto 8 );

              when IP_length =>

                tx_IP_state_r <= ID;

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

              when ID =>

                tx_IP_state_r <= flags_offset;

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

              when flags_offset =>

                tx_IP_state_r <= TTL_protocol;

                -- this block is made for direct communication, not router

                -- networks, so 1 to TTL field should do. Still, just in case,

                -- we'll put there a 5.

                header_data_out( 7 downto 0 )  <= "00000101";

                -- protocol is UDP

                header_data_out( 15 downto 8 ) <= UDP_protocol_c;

              when TTL_protocol =>

                tx_IP_state_r <= header_checksum;

                header_data_out <= ip_checksum( 7 downto 0 ) & ip_checksum( 15 downto 8 );

              when header_checksum =>

                tx_IP_state_r <= source_addr1;

                header_data_out <= own_ip_c( 23 downto 16 ) & own_ip_c( 31 downto 24 );

              when source_addr1 =>

                tx_IP_state_r <= source_addr2;

                header_data_out <= own_ip_c( 7 downto 0 ) & own_ip_c( 15 downto 8 );

              when source_addr2 =>

                tx_IP_state_r <= dest_addr1;

                header_data_out <= target_addr_r( 23 downto 16 ) & target_addr_r( 31 downto 24 );

              when dest_addr1 =>

                tx_IP_state_r <= dest_addr2;

                header_data_out <= target_addr_r( 7 downto 0 ) & target_addr_r( 15 downto 8 );

              when dest_addr2 =>

                -- all written, move on to write the UDP addr

                tx_state_r <= write_UDP_headers;

                tx_IP_state_r <= version_IHL_DS;

                -- first UDP data

                header_data_out <= source_port_r( 7 downto 0 ) & source_port_r( 15 downto 8 );

              when others => null;

            end case;

          end if;

        when write_UDP_headers =>

          if ethernet_re_in = '1' then

            case tx_UDP_state_r is

              when source_port =>

                tx_UDP_state_r <= dest_port;

                header_data_out <= target_port_r( 7 downto 0 ) & target_port_r( 15 downto 8 );

              when dest_port =>

                tx_UDP_state_r <= UDP_length;

                tx_len_slv_v := std_logic_vector( to_unsigned( tx_len_r -

                                                               IP_header_words_c*4, 16 ));

                header_data_out <= tx_len_slv_v( 7 downto 0 ) & tx_len_slv_v( 15 downto 8 );

              when UDP_length =>

                tx_UDP_state_r <= UDP_checksum;

                -- not used

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

              when UDP_checksum =>

                -- all done, start relaying the data

                header_data_valid_out <= '0';

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

                tx_UDP_state_r        <= source_port;

                tx_state_r            <= relay_tx_data;

                output_select_out     <= "10";

                -- remove headers from length

                tx_len_r <= tx_len_r - IP_header_words_c*4 - UDP_header_length_c;

              when others => null;

            end case;

          end if;

        when relay_tx_data =>

          -- count the amount of sent data and go back to idle after all is sent

          if ethernet_re_in = '1' then

            if tx_len_r <= 2 then

              -- all sent

              tx_len_r          <= 0;