Subversion Repositories funbase_ip_library

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

-- arp3.vhd

--

-- Author(s):     Jussi Nieminen after Ashley Partis and Jorgen Peddersen

-- Created:       Feb 2001

-- Last Modified: 2009-09-03

-- 

-- Manages an ARP table for the network stack project.  This protocol listens

-- to incoming data and when an ARP request or reply arrives, the data of the

-- source is added to the ARP table.  The ARP table contains two entries.

-- When a request arrives a signal is also asserted telling the arp sender to

-- send an ARP reply when possible.  The incoming data from the ethernet layer

-- is a byte stream.

-- Licenced under LGPL.

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

library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.numeric_std.all;

use work.udp_ip_pkg.all;

entity ARP is

  port (

    clk               : in  std_logic;  -- clock signal

    rstn              : in  std_logic;  -- asynchronous active low reset

    new_frame_in      : in  std_logic;  -- from ethernet layer indicates data arrival

    new_word_valid_in : in  std_logic;  -- indicates a new word in the stream

    frame_re_out      : out std_logic;

    frame_data_in     : in  std_logic_vector (15 downto 0);  -- the stream data

    frame_valid_in    : in  std_logic;  -- indicates validity

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

    sending_reply_in  : in  std_logic;  -- ARP sender asserts this when the reply is been transmitted

    req_IP_in         : in  std_logic_vector (31 downto 0);  -- ARP sender can request MACs for this address

    gen_ARP_rep_out   : out std_logic;  -- tell ARP sender to generate a reply

    gen_ARP_IP_out    : out std_logic_vector (31 downto 0);  -- destination IP for generated reply

    lookup_MAC_out    : out std_logic_vector (47 downto 0);  -- if valid, MAC for requested IP

    valid_entry_out   : out std_logic;   -- indicates if req_IP_in is in table

    done_out          : out std_logic

    );

end ARP;

architecture ARP_arch of ARP is

-- State signals and types

  type STATETYPE is (stIdle, stHandleARP, stOperate, stCheckValid);

  signal presState : STATETYPE;

  signal nextState : STATETYPE;

  -- range of 0 to 25 should be enough, but just to be sure..

  signal cnt    : integer range 0 to 2**tx_len_w_c-1;

  signal incCnt : std_logic;              -- signal to increment cnt

  signal rstCnt : std_logic;              -- signal to clear cnt

  signal latchFrameData   : std_logic;  -- signal to latch stream data

  signal frameData_r      : std_logic_vector (15 downto 0);  -- register for latched data

  signal shiftSourceIPIn  : std_logic;  -- signal to shift in source IP

  signal source_IP_r      : std_logic_vector (31 downto 0);  -- stores source IP

  signal shiftSourceMACIn : std_logic;  -- signal to shift in source MAC

  signal source_MAC_r     : std_logic_vector (47 downto 0);  -- stores source MAC

  signal ARP_operation_r    : std_logic;  -- '0' for reply, '1' for request

  signal determineOperation : std_logic;  -- signal to latch ARP_operation_r from stream

  signal updateARPTable      : std_logic;  -- this signal updates the ARP table

  signal ARP_entry_IP_r      : std_logic_vector (31 downto 0);  -- most recent ARP entry IP

  signal ARP_entry_MAC_r     : std_logic_vector (47 downto 0);  -- most recent ARP entry MAC

  signal ARP_entry_IP_old_r  : std_logic_vector (31 downto 0);  -- 2nd ARP entry IP

  signal ARP_entry_MAC_old_r : std_logic_vector (47 downto 0);  -- 2nd ARP entry MAC

  signal doGenARPRep : std_logic;       -- asserted when an ARP reply must be generated

  signal frame_len_r : integer range 0 to 2**tx_len_w_c-1;

  signal frame_invalid_r : std_logic;

  signal frame_invalid : std_logic;

  signal clear_invalid : std_logic;

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

begin

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

  process (clk, rstn)

  begin

    if rstn = '0' then                  -- reset state and ARP entries

      presState           <= stIdle;

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

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

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

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

      frame_re_out <= '0';

      cnt <= 0;

      ARP_operation_r <= '0';

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

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

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

      frame_invalid_r <= '0';

      gen_ARP_rep_out <= '0';

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

    elsif clk'event and clk = '1' then

      presState <= nextState;           -- go to next state

      frame_re_out <= '0';

      if incCnt = '1' then              -- handle counter

        cnt <= cnt + 1;

      elsif rstCnt = '1' then

        cnt <= 0;

      end if;

      if latchFrameData = '1' then      -- latch stream data

        frameData_r <= frame_data_in;

        frame_re_out <= '1';

      end if;

      if determineOperation = '1' then  -- determine ARP Operation value

        ARP_operation_r <= frameData_r(8);

      end if;

      if shiftSourceIPIn = '1' then     -- shift in IP

        source_IP_r <= source_IP_r (15 downto 0) &

                       frameData_r( 7 downto 0 ) & frameData_r( 15 downto 8 );

      end if;

      if shiftSourceMACIn = '1' then    -- shift in MAC

        source_MAC_r <= source_MAC_r (31 downto 0) &

                        frameData_r( 7 downto 0 ) & frameData_r( 15 downto 8 );

      end if;

      if updateARPTable = '1' then      -- update ARP table

        if ARP_entry_IP_r = source_IP_r then  -- We already have this ARP, so update

          ARP_entry_MAC_r     <= source_MAC_r;

        else                            -- Lose one old ARP entry and add new one.

          ARP_entry_IP_old_r  <= ARP_entry_IP_r;

          ARP_entry_MAC_old_r <= ARP_entry_MAC_r;

          ARP_entry_IP_r      <= source_IP_r;

          ARP_entry_MAC_r     <= source_MAC_r;

        end if;

      end if;

      if frame_invalid = '1' then

        frame_invalid_r <= '1';

      elsif clear_invalid = '1' then

        frame_invalid_r <= '0';

      end if;

      if new_frame_in = '1' then

        frame_len_r <= to_integer( unsigned( frame_len_in ));

      end if;

      -- gen_ARP_rep_out is asserted by doGenARPRep and will stay high until cleared 

      -- by sending_reply_in

      if doGenARPRep = '1' then

        gen_ARP_rep_out <= '1';         -- when a request is needed assert gen_ARP_rep_out

        gen_ARP_IP_out  <= source_IP_r;  -- and latch the outgoing address

      elsif sending_reply_in = '1' then

        gen_ARP_rep_out <= '0';         -- when the request is been generated, stop requesting

      end if;

    end if;

  end process;

  process (presState, ARP_operation_r, cnt, new_frame_in, frame_invalid_r,

           new_word_valid_in, frameData_r, frame_valid_in, frame_len_r)

  begin

    -- defaulting of signals

    rstCnt             <= '0';

    incCnt             <= '0';

    shiftSourceIPIn    <= '0';

    determineOperation <= '0';

    updateARPTable     <= '0';

    shiftSourceIPIn    <= '0';

    shiftSourceMACIn   <= '0';

    latchFrameData     <= '0';

    doGenARPRep        <= '0';

    frame_invalid      <= '0';

    clear_invalid      <= '0';

    done_out           <= '0';

    case presState is

      when stIdle =>

        -- wait for an ARP frame to arrive (udp_ip makes sure that it really is

        -- an ARP frame)

        if new_frame_in = '1' then

          nextState <= stHandleARP;

          rstCnt    <= '1';

        else

          -- if there is data still coming to ARP, just pretend to be reading it

          if new_word_valid_in = '1' then

            latchFrameData <= '1';

          end if;

          nextState <= stIdle;

        end if;

      when stHandleARP =>

        -- receive a byte from the stream

        if new_word_valid_in = '0' then

          nextState      <= stHandleARP;

        else

          nextState      <= stOperate;

          latchFrameData <= '1';

        end if;

      when stOperate =>

        -- increment counter

        incCnt <= '1';

        -- choose state based on values in the header

        -- The following will make us ignore the frame (all values hexadecimal):

        -- Hardware Type /= 1

        -- Protocol Type /= 800

        -- Hardware Length /= 6

        -- Protocol Length /= 4

        -- Operation /= 1 or 2

        -- Target IP /= our IP (i.e. message is not meant for us)

        if (cnt = 0 and frameData_r /= x"0100") or

          (cnt = 1 and frameData_r /= x"0008") or  -- MSByte = 0 to 7, LSByte = 8 to 15

          (cnt = 2 and frameData_r /= x"0406") or

          (cnt = 3 and frameData_r /= x"0100" and frameData_r /= x"0200") or

          (cnt = 12 and frameData_r /= own_ip_c( 23 downto 16 ) & own_ip_c( 31 downto 24 )) or

          (cnt = 13 and frameData_r /= own_ip_c( 7 downto 0 ) & own_ip_c( 15 downto 8 )) then

          --if ((cnt = "00000" or cnt = "00011" or cnt = "00110") and frameData_r /= 0 )or

          --  (cnt = "00001" and frameData_r /= 1) or

          --  (cnt = "00010" and frameData_r /= 8) or

          --  (cnt = "00100" and frameData_r /= 6) or

          --  (cnt = "00101" and frameData_r /= 4) or

          --  (cnt = "00111" and frameData_r /= 1 and frameData_r /= 2 )or

          --  (cnt = "11000" and frameData_r /= DEVICE_IP (31 downto 24)) or

          --  (cnt = "11001" and frameData_r /= DEVICE_IP (23 downto 16)) or

          --  (cnt = "11010" and frameData_r /= DEVICE_IP (15 downto 8)) or

          --  (cnt = "11011" and frameData_r /= DEVICE_IP (7 downto 0)) then

          frame_invalid <= '1';

        end if;

        -- frame len is in bytes, so divide by two

        if cnt = frame_len_r/2-1 then

          nextState <= stCheckValid;  -- exit when data is totally received

        else

          nextState <= stHandleARP;   -- otherwise loop until complete

        end if;

        -- latch and shift in signals from stream when needed

        if cnt = 3 then

          determineOperation <= '1';

        end if;

        if cnt = 4 or cnt = 5 or cnt = 6 then

          shiftSourceMACIn   <= '1';

        end if;

        if cnt = 7 or cnt = 8 then

          shiftSourceIPIn    <= '1';

        end if;

      when stCheckValid =>

        clear_invalid <= '1';

        done_out  <= '1';

        nextState <= stIdle;

        if frame_valid_in = '1' and frame_invalid_r = '0' then

          -- frame didn't fail CRC and it's not invalid in any other way either

          -- generate a reply if required and wait for more messages

          if ARP_operation_r = '1' then

            doGenARPRep  <= '1';

          end if;

          updateARPTable <= '1';        -- update the ARP table with the new data

        end if;

      when others => null;

    end case;

  end process;

  -- handle requests for entries in the ARP table.

  process (req_IP_in, ARP_entry_IP_r, ARP_entry_MAC_r, ARP_entry_IP_old_r, ARP_entry_MAC_old_r)

  begin

    if req_IP_in = ARP_entry_IP_r then  -- check most recent entry

      valid_entry_out <= '1';

      lookup_MAC_out  <= ARP_entry_MAC_r;

    elsif req_IP_in = ARP_entry_IP_old_r then  -- check 2nd entry

      valid_entry_out <= '1';

      lookup_MAC_out  <= ARP_entry_MAC_old_r;

    else                                -- if neither entry matches, valid = 0

      valid_entry_out <= '0';

      lookup_MAC_out  <= (others => '1');

    end if;

  end process;

end ARP_arch;