Subversion Repositories udp_ip_stack

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

-- Company: 

-- Engineer:            Peter Fall

-- 

-- Create Date:    12:00:04 05/31/2011 

-- Design Name: 

-- Module Name:    arp_REQ - Behavioral 

-- Project Name: 

-- Target Devices: 

-- Tool versions: 

-- Description:

--              handle requests for ARP resolution

--              responds from single entry cache or searches external arp store, or asks to send a request

--

-- Dependencies: 

--

-- Revision: 

-- Revision 0.01 - File Created from arp.vhd 0.2

-- Additional Comments: 

--

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

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

use work.arp_types.all;

entity arp_req is

         generic (

                        CLOCK_FREQ                       : integer := 125000000;                        -- freq of data_in_clk -- needed to timout cntr

                        ARP_TIMEOUT                      : integer := 60;                                               -- ARP response timeout (s)

                        ARP_MAX_PKT_TMO  : integer := 5                                         -- # wrong nwk pkts received before set error

                        );

    Port (

                        -- lookup request signals

                        arp_req_req                     : in arp_req_req_type;                          -- request for a translation from IP to MAC

                        arp_req_rslt            : out arp_req_rslt_type;                        -- the result

                        -- external arp store signals

                        arp_store_req           : out arp_store_rdrequest_t;            -- requesting a lookup or store

                        arp_store_result        : in arp_store_result_t;                        -- the result

                        -- network request signals

                        arp_nwk_req                     : out arp_nwk_request_t;                        -- requesting resolution via the network

                        arp_nwk_result          : in arp_nwk_result_t;                          -- the result

                        -- system signals

                        clear_cache                     : in std_logic;                                         -- clear the internal cache

                        clk                                     : in std_logic;

                        reset                           : in  STD_LOGIC

                        );

end arp_req;

architecture Behavioral of arp_req is

        type req_state_t is (IDLE,LOOKUP,WAIT_REPLY,PAUSE1,PAUSE2,PAUSE3);

        type set_cntr_t is (HOLD,CLR,INCR);

        type set_clr_type is (SET, CLR, HOLD);

        -- state variables

        signal req_state                                : req_state_t;

        signal req_ip_addr                      : std_logic_vector (31 downto 0);                -- IP address to lookup

        signal arp_entry_cache          : arp_entry_t;                                                                  -- single entry cache for fast response

        signal cache_valid                      : std_logic;                                                                    -- single entry cache is valid

        signal nwk_rx_cntr                      : unsigned(7 downto 0);                                          -- counts nwk rx pkts that dont satisfy

        signal freq_scaler                      : unsigned (31 downto 0);                                        -- scales data_in_clk downto 1Hz

        signal timer                                    : unsigned (7 downto 0);                                 -- counts seconds timeout

        signal timeout_reg                      : std_logic;

        -- busses

        signal next_req_state           : req_state_t;

        signal arp_entry_val                    : arp_entry_t;

        -- requester control signals

        signal set_req_state                    : std_logic;

        signal set_req_ip                               : std_logic;

        signal store_arp_cache          : std_logic;

        signal set_nwk_rx_cntr          : set_cntr_t;

        signal set_timer                                : set_cntr_t;                           -- timer reset, count, hold control

        signal timer_enable                     : std_logic;                            -- enable the timer counting

        signal set_timeout                      : set_clr_type;                 -- control the timeout register

        signal clear_cache_valid        : std_logic;

begin

        req_combinatorial : process (

                -- input signals

                arp_req_req, arp_store_result, arp_nwk_result, clear_cache,

                -- state variables

                req_state, req_ip_addr, arp_entry_cache, cache_valid, nwk_rx_cntr,

                freq_scaler, timer, timeout_reg,

                -- busses

                next_req_state, arp_entry_val,

                -- control signals

                set_req_state, set_req_ip, store_arp_cache, set_nwk_rx_cntr, clear_cache_valid,

                set_timer, timer_enable, set_timeout

                )

        begin

                -- set output followers

                arp_req_rslt.got_mac <= '0';     -- set initial value of request result outputs

                arp_req_rslt.got_err <= '0';

                arp_req_rslt.mac <= (others => '0');

                arp_store_req.req <= '0';

                arp_store_req.ip <= (others => '0');

                arp_nwk_req.req <= '0';

                arp_nwk_req.ip <= (others => '0');

                -- zero time response to lookup request if already in cache

                if arp_req_req.lookup_req = '1' and arp_req_req.ip = arp_entry_cache.ip and cache_valid = '1' then

                        arp_req_rslt.got_mac <= '1';

                        arp_req_rslt.mac <= arp_entry_cache.mac;

                elsif arp_req_req.lookup_req = '1' then

                        -- hold off got_mac while req is there as arp_entry will not be correct yet

                        arp_req_rslt.got_mac <= '0';

                        arp_req_rslt.mac <= arp_entry_cache.mac;

                else

                        arp_req_rslt.got_mac <= cache_valid;

                        arp_req_rslt.mac <= arp_entry_cache.mac;

                end if;

                if arp_req_req.lookup_req = '1' then

                        -- ensure any existing error report is killed at the start of a request

                        arp_req_rslt.got_err <= '0';

                else

                        arp_req_rslt.got_err <= timeout_reg;

                end if;

                -- set signal defaults

                next_req_state <= IDLE;

                set_req_state <= '0';

                set_req_ip <= '0';

                store_arp_cache <= '0';

                arp_entry_val.ip <= (others => '0');

                arp_entry_val.mac <= (others => '0');

                set_nwk_rx_cntr <= HOLD;

                set_timer <= INCR;                      -- default is timer running, unless we hold or reset it

                set_timeout <= HOLD;

                timer_enable <= '0';

                clear_cache_valid <= clear_cache;

                -- combinatorial logic

                if freq_scaler = x"00000000" then

                                timer_enable <= '1';

                end if;

                -- REQ FSM

                case req_state is

                        when IDLE =>

                                set_timer <= CLR;

                                if arp_req_req.lookup_req = '1' then

                                        -- check if we already have the info in cache

                                        if arp_req_req.ip = arp_entry_cache.ip and cache_valid = '1' then

                                                -- already have this IP - feed output back

                                                arp_req_rslt.got_mac <= '1';

                                                arp_req_rslt.mac <= arp_entry_cache.mac;

                                        else

                                                clear_cache_valid <= '1';               -- remove cache entry

                                                set_timeout <= CLR;

                                                next_req_state <= LOOKUP;

                                                set_req_state <= '1';

                                                set_req_ip <= '1';

                                        end if;

                                end if;

                        when LOOKUP =>

                                -- put request on the store

                                arp_store_req.ip <= req_ip_addr;

                                arp_store_req.req <= '1';

                                case arp_store_result.status is

                                        when FOUND =>

                                                -- update the cache

                                                arp_entry_val <= arp_store_result.entry;

                                                store_arp_cache <= '1';

                                                -- and feed output back

                                                arp_req_rslt.got_mac <= '1';

                                                arp_req_rslt.mac <= arp_store_result.entry.mac;

                                                next_req_state <= IDLE;

                                                set_req_state <= '1';

                                        when NOT_FOUND =>

                                                -- need to request from the network

                                                set_timer <= CLR;

                                                set_nwk_rx_cntr <= CLR;

                                                arp_nwk_req.req <= '1';

                                                arp_nwk_req.ip <= req_ip_addr;

                                                next_req_state <= WAIT_REPLY;

                                                set_req_state <= '1';

                                        when OTHERS =>

                                                -- just keep waiting - no timeout (assumes lookup with either succeed or fail)

                                end case;

                        when WAIT_REPLY =>

                                case arp_nwk_result.status is

                                        when RECEIVED =>

                                                -- store into cache

                                                arp_entry_val <= arp_nwk_result.entry;

                                                store_arp_cache <= '1';

                                                -- and feed output back

                                                if arp_nwk_result.entry.ip = req_ip_addr then

                                                        arp_req_rslt.got_mac <= '1';

                                                        arp_req_rslt.mac <= arp_nwk_result.entry.mac;

                                                        next_req_state <= IDLE;

                                                        set_req_state <= '1';

                                                else

                                                        if nwk_rx_cntr > ARP_MAX_PKT_TMO then

                                                                set_timeout <= SET;

                                                                next_req_state <= IDLE;

                                                                set_req_state <= '1';

                                                        else

                                                                set_nwk_rx_cntr <= INCR;

                                                        end if;

                                                end if;

                                        when ERROR =>

                                                set_timeout <= SET;

                                        when OTHERS =>

                                                if timer >= ARP_TIMEOUT then

                                                        set_timeout <= SET;

                                                        next_req_state <= PAUSE1;

                                                        set_req_state <= '1';

                                                end if;

                                end case;

                        when PAUSE1 =>

                                        next_req_state <= PAUSE2;

                                        set_req_state <= '1';

                        when PAUSE2 =>

                                        next_req_state <= PAUSE3;

                                        set_req_state <= '1';

                        when PAUSE3 =>

                                        next_req_state <= IDLE;

                                        set_req_state <= '1';

                end case;

        end process;

        req_sequential : process (clk)

        begin

                if rising_edge(clk) then

                        if reset = '1' then

                                -- reset state variables

                                req_state <= IDLE;

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

                                arp_entry_cache.ip <= (others => '0');

                                arp_entry_cache.mac <= (others => '0');

                                cache_valid <= '0';

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

                                freq_scaler <= to_unsigned(CLOCK_FREQ,32);

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

                                timeout_reg <= '0';

                        else

                                -- Next req_state processing

                                if set_req_state = '1' then

                                        req_state <= next_req_state;

                                else

                                        req_state <= req_state;

                                end if;

                                -- Latch the requested IP address

                                if set_req_ip = '1' then

                                        req_ip_addr <= arp_req_req.ip;

                                else

                                        req_ip_addr <= req_ip_addr;

                                end if;

                                -- network received counter

                                case set_nwk_rx_cntr is

                                        when CLR  => nwk_rx_cntr <= (others => '0');

                                        when INCR => nwk_rx_cntr <= nwk_rx_cntr + 1;

                                        when HOLD => nwk_rx_cntr <= nwk_rx_cntr;

                                end case;

                                -- set the arp_entry_cache

                                if clear_cache_valid = '1' then

                                        arp_entry_cache <= arp_entry_cache;

                                        cache_valid <= '0';

                                elsif store_arp_cache = '1' then

                                        arp_entry_cache <= arp_entry_val;

                                        cache_valid <= '1';

                                else

                                        arp_entry_cache <= arp_entry_cache;

                                        cache_valid <= cache_valid;

                                end if;

                                -- freq scaling and 1-sec timer

                                if freq_scaler = x"00000000" then

                                        freq_scaler <= to_unsigned(CLOCK_FREQ,32);

                                else

                                        freq_scaler <= freq_scaler - 1;

                                end if;

                                -- timer processing

                                case set_timer is

                                        when CLR =>

                                                timer <= x"00";

                                        when INCR =>

                                                if timer_enable = '1' then

                                                        timer <= timer + 1;

                                                else

                                                        timer <= timer;

                                                end if;

                                        when HOLD =>

                                                timer <= timer;

                                end case;

                                -- timeout latching

                                case set_timeout is

                                        when CLR  => timeout_reg <= '0';

                                        when SET  => timeout_reg <= '1';

                                        when HOLD => timeout_reg <= timeout_reg;

                                end case;

                        end if;

                end if;

        end process;

end Behavioral;