Subversion Repositories udp_ip_stack

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

-- Company: 

-- Engineer:            Peter Fall

-- 

-- Create Date:    5 June 2011 

-- Design Name: 

-- Module Name:    UDP_RX - Behavioral 

-- Project Name: 

-- Target Devices: 

-- Tool versions: 

-- Description: 

--              handle simple UDP RX

--              doesnt check the checsum

-- Dependencies: 

--

-- Revision: 

-- Revision 0.01 - File Created

-- Revision 0.02 - Improved error handling

-- Additional Comments: 

--

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

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

use work.axi.all;

use work.ipv4_types.all;

entity UDP_RX is

    Port (

                        -- UDP Layer signals

                        udp_rx_start                    : out std_logic;                                                        -- indicates receipt of udp header

                        udp_rxo                                 : out udp_rx_type;

                        -- system signals

                        clk                                             : in  STD_LOGIC;

                        reset                                   : in  STD_LOGIC;

                        -- IP layer RX signals

                        ip_rx_start                             : in std_logic;                                                 -- indicates receipt of ip header

                        ip_rx                                           : in ipv4_rx_type

                        );

end UDP_RX;

architecture Behavioral of UDP_RX is

        type rx_state_type is (IDLE, UDP_HDR, USER_DATA, WAIT_END, ERR);

        type rx_event_type is (NO_EVENT,DATA);

        type count_mode_type is (RST, INCR, HOLD);

        type settable_count_mode_type is (RST, INCR, SET_VAL, HOLD);

        type set_clr_type is (SET, CLR, HOLD);

        -- state variables

        signal rx_state                         : rx_state_type;

        signal rx_count                         : unsigned (15 downto 0);

        signal src_port                 : std_logic_vector (15 downto 0);        -- src port captured from input

        signal dst_port                 : std_logic_vector (15 downto 0);        -- dst port captured from input

        signal data_len                 : std_logic_vector (15 downto 0);        -- user data length captured from input

        signal udp_rx_start_reg : std_logic;                                                            -- indicates start of user data

        signal hdr_valid_reg            : std_logic;                                                            -- indicates that hdr data is valid

        signal src_ip_addr              : std_logic_vector (31 downto 0);        -- captured from IP hdr

        -- rx control signals

        signal next_rx_state    : rx_state_type;

        signal set_rx_state             : std_logic;

        signal rx_event                         : rx_event_type;

        signal rx_count_mode    : settable_count_mode_type;

        signal rx_count_val             : unsigned (15 downto 0);

        signal set_sph                  : std_logic;

        signal set_spl                  : std_logic;

        signal set_dph                  : std_logic;

        signal set_dpl                  : std_logic;

        signal set_len_H                        : std_logic;

        signal set_len_L                        : std_logic;

        signal set_udp_rx_start : set_clr_type;

        signal set_hdr_valid    : set_clr_type;

        signal dataval                  : std_logic_vector (7 downto 0);

        signal set_pkt_cnt              : count_mode_type;

        signal set_src_ip                       : std_logic;

        signal set_data_last            : std_logic;

-- IP datagram header format

--

--      0          4          8                      16      19             24                    31

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

--      |              source port number            |              dest port number               |

--      |                                            |                                             |

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

--      |                length (bytes)              |                checksum                     |

--      |          (header and data combined)        |                                             |

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

--      |                                          Data                                            |

--      |                                                                                          |

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

--      |                                          ....                                            |

--      |                                                                                          |

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

begin

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

        -- combinatorial process to implement FSM and determine control signals

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

        rx_combinatorial : process (

                -- input signals

                ip_rx, ip_rx_start,

                -- state variables

                rx_state, rx_count, src_port, dst_port, data_len, udp_rx_start_reg, hdr_valid_reg, src_ip_addr,

                -- control signals

                next_rx_state, set_rx_state, rx_event, rx_count_mode, rx_count_val,

                set_sph, set_spl, set_dph, set_dpl, set_len_H, set_len_L, set_data_last,

                set_udp_rx_start, set_hdr_valid, dataval, set_pkt_cnt, set_src_ip

                )

        begin

                -- set output followers

                udp_rx_start <= udp_rx_start_reg;

                udp_rxo.hdr.is_valid <= hdr_valid_reg;

                udp_rxo.hdr.data_length <= data_len;

                udp_rxo.hdr.src_port <= src_port;

                udp_rxo.hdr.dst_port <= dst_port;

                udp_rxo.hdr.src_ip_addr <= src_ip_addr;

                -- transfer data upstream if in user data phase

                if rx_state = USER_DATA then

                        udp_rxo.data.data_in <= ip_rx.data.data_in;

                        udp_rxo.data.data_in_valid <= ip_rx.data.data_in_valid;

                        udp_rxo.data.data_in_last <= set_data_last;

                else

                        udp_rxo.data.data_in <= (others => '0');

                        udp_rxo.data.data_in_valid <= '0';

                        udp_rxo.data.data_in_last <= '0';

                end if;

                -- set signal defaults

                next_rx_state <= IDLE;

                set_rx_state <= '0';

                rx_event <= NO_EVENT;

                rx_count_mode <= HOLD;

                set_sph <= '0';

                set_spl <= '0';

                set_dph <= '0';

                set_dpl <= '0';

                set_len_H <= '0';

                set_len_L <= '0';

                set_udp_rx_start <= HOLD;

                set_hdr_valid <= HOLD;

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

                set_src_ip <= '0';

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

                set_data_last <= '0';

                -- determine event (if any)

                if ip_rx.data.data_in_valid = '1' then

                        rx_event <= DATA;

                        dataval <= ip_rx.data.data_in;

                end if;

                -- RX FSM

                case rx_state is

                        when IDLE =>

                                rx_count_mode <= RST;

                                case rx_event is

                                        when NO_EVENT => -- (nothing to do)

                                        when DATA =>

                                                if ip_rx.hdr.protocol = x"11" then

                                                        -- UDP protocol

                                                        rx_count_mode <= INCR;

                                                        set_hdr_valid <= CLR;

                                                        set_src_ip <= '1';

                                                        set_sph <= '1';

                                                        next_rx_state <= UDP_HDR;

                                                        set_rx_state <= '1';

                                                else

                                                        -- non-UDP protocol - ignore this pkt

                                                        set_hdr_valid <= CLR;

                                                        next_rx_state <= WAIT_END;

                                                        set_rx_state <= '1';

                                                end if;

                                end case;

                        when UDP_HDR =>

                                case rx_event is

                                        when NO_EVENT => -- (nothing to do)

                                        when DATA =>

                                                if rx_count = x"0007" then

                                                        rx_count_mode <= SET_VAL;

                                                        rx_count_val <= x"0001";

                                                        next_rx_state <= USER_DATA;

                                                        set_rx_state <= '1';

                                                else

                                                        rx_count_mode <= INCR;

                                                end if;

                                                -- handle early frame termination

                                                if ip_rx.data.data_in_last = '1' then

                                                        next_rx_state <= ERR;

                                                        set_rx_state <= '1';

                                                else

                                                        case rx_count is

                                                                when x"0000" => set_sph <= '1';

                                                                when x"0001" => set_spl <= '1';

                                                                when x"0002" => set_dph <= '1';

                                                                when x"0003" => set_dpl <= '1';

                                                                when x"0004" => set_len_H <= '1';

                                                                when x"0005" => set_len_L <= '1'; set_hdr_valid <= SET; -- header values are now valid, although the pkt may not be for us

                                                                when x"0006" => -- ignore checksum values

                                                                when x"0007" => set_udp_rx_start <= SET;                -- indicate frame received

                                                                when others => -- ignore other bytes in udp header                                                                              

                                                        end case;

                                                end if;

                                end case;

                        when USER_DATA =>

                                case rx_event is

                                        when NO_EVENT => -- (nothing to do)

                                        when DATA =>

                                                -- note: data gets transfered upstream as part of "output followers" processing

                                                if rx_count = unsigned(data_len) then

                                                        set_udp_rx_start <= CLR;

                                                        rx_count_mode <= RST;

                                                        set_data_last <= '1';

                                                        if ip_rx.data.data_in_last = '1' then

                                                                next_rx_state <= IDLE;

                                                                set_udp_rx_start <= CLR;

                                                        else

                                                                next_rx_state <= WAIT_END;

                                                        end if;

                                                        set_rx_state <= '1';

                                                else

                                                        rx_count_mode <= INCR;

                                                        -- check for early frame termination

                                                        -- TODO need to mark frame as errored

                                                        if ip_rx.data.data_in_last = '1' then

                                                                next_rx_state <= IDLE;

                                                                set_rx_state <= '1';

                                                                set_data_last <= '1';

                                                        end if;

                                                end if;

                                end case;

                        when ERR =>

                                if ip_rx.data.data_in_last = '0' then

                                        next_rx_state <= WAIT_END;

                                        set_rx_state <= '1';

                                else

                                        next_rx_state <= IDLE;

                                        set_rx_state <= '1';

                                end if;

                        when WAIT_END =>

                                case rx_event is

                                        when NO_EVENT => -- (nothing to do)

                                        when DATA =>

                                                if ip_rx.data.data_in_last = '1' then

                                                        next_rx_state <= IDLE;

                                                        set_rx_state <= '1';

                                                end if;

                                end case;

                end case;

        end process;

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

        -- sequential process to action control signals and change states and outputs

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

        rx_sequential : process (clk,reset)

        begin

                if rising_edge(clk) then

                        if reset = '1' then

                                -- reset state variables

                                rx_state <= IDLE;

                                rx_count <= x"0000";

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

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

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

                                udp_rx_start_reg <= '0';

                                hdr_valid_reg <= '0';

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

                        else

                                -- Next rx_state processing

                                if set_rx_state = '1' then

                                        rx_state <= next_rx_state;

                                else

                                        rx_state <= rx_state;

                                end if;

                                -- rx_count processing

                                case rx_count_mode is

                                        when RST =>             rx_count <= x"0000";

                                        when INCR =>            rx_count <= rx_count + 1;

                                        when SET_VAL => rx_count <= rx_count_val;

                                        when HOLD =>            rx_count <= rx_count;

                                end case;

                                -- port number capture

                                if (set_sph = '1') then src_port(15 downto 8) <= dataval; end if;

                                if (set_spl = '1') then src_port(7 downto 0) <= dataval; end if;

                                if (set_dph = '1') then dst_port(15 downto 8) <= dataval; end if;

                                if (set_dpl = '1') then dst_port(7 downto 0) <= dataval; end if;

                                if (set_len_H = '1') then

                                        data_len (15 downto 8) <= dataval;

                                        data_len (7 downto 0) <= x"00";

                                elsif (set_len_L = '1') then

                                        -- compute data length, taking into account that we need to subtract the header length

                                        data_len <= std_logic_vector(unsigned(data_len(15 downto 8) & dataval) - 8);

                                else

                                        data_len <= data_len;

                                end if;

                                case set_udp_rx_start is

                                        when SET => udp_rx_start_reg <= '1';

                                        when CLR => udp_rx_start_reg <= '0';

                                        when HOLD => udp_rx_start_reg <= udp_rx_start_reg;

                                end case;

                                -- capture src IP address

                                if set_src_ip = '1' then

                                        src_ip_addr <= ip_rx.hdr.src_ip_addr;

                                else

                                        src_ip_addr <= src_ip_addr;

                                end if;

                                case set_hdr_valid is

                                        when SET => hdr_valid_reg <= '1';

                                        when CLR => hdr_valid_reg <= '0';

                                        when HOLD => hdr_valid_reg <= hdr_valid_reg;

                                end case;

                        end if;

                end if;

        end process;

end Behavioral;