Subversion Repositories funbase_ip_library

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

-- arpsnd.vhd

--

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

-- Created:       Feb 2001

-- Last Modified: Feb 2001

-- 

-- Sits transparently between the internet send and ethernet send layers.

-- All frame send requests from the internet layer are passed through after

-- the destination MAC is either looked up from the ARP table, or an ARP 

-- request is sent out and an ARP reply is receiver.  ARP replies are created

-- and then sent to the ethernet later after being requested by the ARP layer.  

-- After each frame is passed on to the ethernet layer and then sent, it informs

-- the layer above that the frame has been sent.

--

-- Licenced under LGPL.

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

library ieee;

use ieee.std_logic_1164.all;

use ieee.std_logic_unsigned.all;

use work.udp_ip_pkg.all;

entity ARPSnd is

  port (

    clk                : in  std_logic;  -- clock

    rstn               : in  std_logic;  -- aysnchronous active low reset

    request_MAC_in     : in  std_logic;  -- IP layer want's to know a MAC addr

    targer_IP_in       : in  std_logic_vector (31 downto 0);  -- destination IP from the internet layer

    ARP_entry_valid_in : in  std_logic;  -- input from ARP indicating that it contains the requested IP

    gen_ARP_reply_in   : in  std_logic;  -- input from ARP requesting an ARP reply

    gen_ARP_IP_in      : in  std_logic_vector (31 downto 0);  -- input from ARP saying which IP to send a reply to

    lookup_MAC_in      : in  std_logic_vector (47 downto 0);  -- input from ARP giving a requested MAC

    lookup_IP_out      : out std_logic_vector (31 downto 0);  -- output to ARP requesting an IP to be looked up in the table

    sending_reply_out  : out std_logic;  -- output to ARP to tell it's sending the ARP reply

    target_MAC_out     : out std_logic_vector (47 downto 0);  -- destination MAC for the physical layer

    requested_MAC_out  : out std_logic_vector( 47 downto 0 );  -- requested MAC to UDP/IP

    req_MAC_valid_out  : out std_logic;

    gen_frame_out      : out std_logic;  -- tell the ethernet layer (PHY) to send a frame

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

    frame_size_out     : out std_logic_vector (10 downto 0);  -- tell the PHY what size the frame size is

    tx_ready_out           : out std_logic;  -- idle signal

    wr_data_valid_out  : out std_logic;

    wr_data_out        : out std_logic_vector (15 downto 0);

    wr_re_in           : in  std_logic

    );

end ARPSnd;

architecture ARPSnd_arch of ARPSnd is

-- FSM state definitions

  type STATETYPE is (stIdle, stGenARPReply, stGetReplyMAC, stStoreARPReply, stCheckARPEntry, stCheckARPEntry2,

                     stGenARPRequest, stStoreARPRequest, stWaitForValidEntry, stGiveMAC);

  signal presState : STATETYPE;

  signal nextState : STATETYPE;

-- signals to synchronously increment and reset the counter

  signal cnt    : std_logic_vector (4 downto 0);

  signal incCnt : std_logic;

  signal rstCnt : std_logic;

-- next write data value

  signal nextWrData : std_logic_vector (15 downto 0);

-- signals and buffers to latch input data

  signal latchTargetIP   : std_logic;

  signal latchInternetIP : std_logic;

  signal IP_r            : std_logic_vector (31 downto 0);

  signal latchTargetMAC  : std_logic;

  signal MAC_r           : std_logic_vector (47 downto 0);

-- 20 second ARP reply timeout counter at 50MHz

  signal ARP_timeout_cnt_r  : std_logic_vector (29 downto 0);

  signal rstARPCnt          : std_logic;

  signal ARP_cnt_overflow_r : std_logic;

  signal wr_data_r     : std_logic_vector( 15 downto 0 );

  signal wr_data_valid : std_logic;

  signal start_tx      : std_logic;

  signal MAC_to_output : std_logic;

  signal req_MAC_valid_r : std_logic;

  constant ARP_frame_size_c : std_logic_vector( 10 downto 0 ) := "00000011100";

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

begin

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

  -- connect output to register

  wr_data_out <= wr_data_r;

  req_MAC_valid_out <= req_MAC_valid_r;

  process (rstn, clk)

  begin

    -- set up the asynchronous active low reset

    if rstn = '0' then

      presState         <= stIdle;

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

      wr_data_valid_out <= '0';

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

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

      ARP_cnt_overflow_r <= '0';

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

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

      gen_frame_out     <= '0';

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

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

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

      req_MAC_valid_r   <= '0';

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

    elsif clk'event and clk = '1' then

      presState <= nextState;

      -- set the write data bus to it's next value

      wr_data_r <= nextWrData;

      -- register valid signal

      if wr_data_valid = '1' then

        wr_data_valid_out <= '1';

      end if;

      -- start a tx

      if start_tx = '1' then

        if latchTargetMAC = '1' then

          target_MAC_out <= lookup_MAC_in;

        else

          target_MAC_out <= x"FFFFFFFFFFFF";

        end if;

        gen_frame_out    <= '1';        -- goes to 'new tx' and 'snd_req' (udp)

        frame_size_out   <= ARP_frame_size_c;

        frame_type_out   <= ARP_frame_type_c;

      end if;

      if wr_re_in = '1' then

        -- clear gen_frame_out when eth cntrl starts to read

        gen_frame_out     <= '0';

        -- also clear the valid signal

        wr_data_valid_out <= '0';

      end if;

      -- increment and reset the counter synchronously to avoid race conditions

      if incCnt = '1' then

        cnt <= cnt + 1;

      elsif rstCnt = '1' then

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

      end if;

      -- set the ARP counter to 1

      if rstARPCnt = '1' then

        ARP_timeout_cnt_r  <= "00" & x"0000001";

        ARP_cnt_overflow_r <= '0';

        -- if the ARP counter isn't 0, keep incrementing it

      elsif ARP_timeout_cnt_r /= "00" & x"0000000" then

        ARP_timeout_cnt_r  <= ARP_timeout_cnt_r + 1;

        ARP_cnt_overflow_r <= '0';

        -- if the counter is 0, set the overflow signal

      else

        ARP_cnt_overflow_r <= '1';

      end if;

      -- latch the IP to send the ARP request to, send the ARP reply to or to lookup

      -- from either the ARP layer or internet send layer

      if latchTargetIP = '1' then

        IP_r <= gen_ARP_IP_in;

      elsif latchInternetIP = '1' then

        IP_r <= targer_IP_in;

      end if;

      -- latch the MAC from the ARP table that has been looked up

      if latchTargetMAC = '1' then

        MAC_r <= lookup_MAC_in;

      end if;

      if MAC_to_output = '1' then

        -- put out the MAC when we have it

        requested_MAC_out <= MAC_r;

        req_MAC_valid_r <= '1';

      elsif request_MAC_in = '0' then

        -- clear the valid signal when IP layer stops requesting

        req_MAC_valid_r <= '0';

      end if;

    end if;

  end process;

-- ARP header format

--

--      0                     8                     16                                             31

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

--      |                Hardware Type               |               Protocol Type                 |

--      |                                            |                                             |

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

--      |   Hardware Address  |   Protocol Address   |                 Operation                   |

--      |       Length        |       Length         |                                             |

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

--      |                          Sender Hardware Address (MAC) (bytes 0 - 3)                     |

--      |                                                                                          |

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

--      |           Sender MAC (bytes 4 - 5)         |        Sender IP Address (bytes 0 - 1)      |

--      |                                            |                                             |

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

--      |            Sender IP (bytes 2 - 3)         |    Target Hardware Address (bytes 0 - 1)    |

--      |                                            |                                             |

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

--      |                                  Target MAC (bytes 2 - 5)                                |

--      |                                                                                          |

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

--      |                               Target IP Address (bytes 0 - 3)                            |

--      |                                                                                          |

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

--

  -- main FSM process

  process (presState, gen_ARP_reply_in, cnt, IP_r, MAC_r, wr_data_r, req_MAC_valid_r,

           ARP_entry_valid_in, ARP_cnt_overflow_r, request_MAC_in, wr_re_in)

  begin

    -- remember the value of the RAM write data bus by default

    nextWrData        <= wr_data_r;

    -- lookup the latched IP by default

    lookup_IP_out     <= IP_r;

    rstCnt            <= '0';

    incCnt            <= '0';

    sending_reply_out <= '0';

    tx_ready_out      <= '0';

    latchInternetIP   <= '0';

    latchTargetIP     <= '0';

    latchTargetMAC    <= '0';

    rstARPCnt         <= '0';

    wr_data_valid     <= '0';

    MAC_to_output     <= '0';

    start_tx <= '0';

    case presState is

      when stIdle =>

        -- wait for a frame to arrive

        -- if req_MAC_valid_r = '1', we have just arrived from state stGiveMAC

        -- and we don't want to get again to stCheckARPEntry.

        if (req_MAC_valid_r = '1' or request_MAC_in = '0')

          and gen_ARP_reply_in = '0'

        then

          nextState    <= stIdle;

          tx_ready_out <= '1';

          rstCnt       <= '1';

          -- create an ARP reply when asked, giving ARP message priority

        elsif gen_ARP_reply_in = '1' then

          nextState     <= stGetReplyMAC;

          -- latch the target IP from the ARP layer

          latchTargetIP <= '1';

        -- IP layer wants to have a MAC address

        else

          nextState       <= stCheckARPEntry;

          -- latch input from the IP layer

          latchInternetIP <= '1';

        end if;

        -- create the ARP reply, getting the target MAC from the ARP table

      when stGetReplyMAC =>

        nextState         <= stGenARPReply;

        lookup_IP_out     <= IP_r;

        latchTargetMAC    <= '1';

        -- tell the ARP table that we're sending the reply

        sending_reply_out <= '1';

        start_tx          <= '1';

        -- generate each byte of the ARP reply according to count

      when stGenARPReply =>

        wr_data_valid <= '1';

        nextState     <= stStoreARPReply;

        case cnt is

          -- Hardware type

          when "00000" =>

            nextWrData <= x"0100";       -- remember, it's x"LSByte MSByte"

          -- Protocol type

          when "00001" =>

            nextWrData <= x"0008";

            -- Hardware and protocol Address lengths in bytes (x"PAL HAL")

          when "00010" =>

            nextWrData <= x"0406";

            -- Operation

          when "00011" =>

            nextWrData <= x"0200";

            -- Sender Hardware Address bytes 1 and 0

          when "00100" =>

            nextWrData <= MAC_addr_c( 39 downto 32 ) & MAC_addr_c (47 downto 40);

            -- Sender Hardware Address bytes 3 and 2

          when "00101" =>

            nextWrData <= MAC_addr_c( 23 downto 16 ) & MAC_addr_c (31 downto 24);

            -- Sender Hardware Address bytes 5 and 4

          when "00110" =>

            nextWrData <= MAC_addr_c( 7 downto 0 ) & MAC_addr_c (15 downto 8);

            -- Sender IP Address bytes 1 and 0

          when "00111" =>

            nextWrData <= own_IP_c( 23 downto 16 ) & own_IP_c (31 downto 24);

            -- Sender IP Address bytes 3 and 2

          when "01000" =>

            nextWrData <= own_IP_c( 7 downto 0 ) & own_IP_c (15 downto 8);

            -- Target Hardware Address bytes 1 and 0

          when "01001" =>

            nextWrData <= MAC_r( 39 downto 32 ) & MAC_r( 47 downto 40 );

            -- Target Hardware Address bytes 3 and 2

          when "01010" =>

            nextWrData <= MAC_r( 23 downto 16 ) & MAC_r( 31 downto 24 );

            -- Target Hardware Address bytes 5 and 4

          when "01011" =>

            nextWrData <= MAC_r( 7 downto 0 ) & MAC_r( 15 downto 8 );

            -- Target IP Address bytes 1 and 0

          when "01100" =>

            nextWrData <= IP_r( 23 downto 16 ) & IP_r (31 downto 24);

            -- Target IP Address bytes 3 and 2

          when "01101" =>

            nextWrData <= IP_r( 7 downto 0 ) & IP_r (15 downto 8);

          when others => null;

        end case;

        -- store the ARP reply for the Ethernet sender

      when stStoreARPReply =>

        if wr_re_in = '1' then

          if cnt = "01101" then

            nextState <= stIdle;

          else

            nextState <= stGenARPReply;

            incCnt    <= '1';

          end if;

        else

          nextState <= stStoreARPReply;

        end if;

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

        -- handle frames passed on to us from the Internet layer

        -- check to the see if the desired IP is in the ARP table

      when stCheckARPEntry =>

        nextState     <= stCheckARPEntry2;

        lookup_IP_out <= IP_r;

        -- check to see if the ARP entry is valid

      when stCheckARPEntry2 =>

        lookup_IP_out    <= IP_r;

        -- if it's not a valid ARP entry, then generate an ARP request to find the

        -- desired MAC address

        if ARP_entry_valid_in = '0' then

          nextState      <= stGenArpRequest;

          start_tx       <= '1';

          -- otherwise pass the MAC to the UDP/IP block

        else

          nextState      <= stGiveMAC;

          latchTargetMAC <= '1';

        end if;

        -- create each byte of the ARP request according to cnt

      when stGenARPRequest =>

        wr_data_valid <= '1';

        nextState <= stStoreARPRequest;

        case cnt is

          -- Hardware type

          when "00000" =>

            nextWrData <= x"0100";       -- remember, it's x"LSByte MSByte"

            -- Protocol type

          when "00001" =>

            nextWrData <= x"0008";

            -- Hardware and protocol Address lengths in bytes (x"PAL HAL")

          when "00010" =>

            nextWrData <= x"0406";

            -- Operation

          when "00011" =>

            nextWrData <= x"0100";

            -- Sender Hardware Address bytes 1 and 0

          when "00100" =>

            nextWrData <= MAC_addr_c( 39 downto 32 ) & MAC_addr_c (47 downto 40);

            -- Sender Hardware Address bytes 3 and 2

          when "00101" =>

            nextWrData <= MAC_addr_c( 23 downto 16 ) & MAC_addr_c (31 downto 24);

            -- Sender Hardware Address bytes 5 and 4

          when "00110" =>

            nextWrData <= MAC_addr_c( 7 downto 0 ) & MAC_addr_c (15 downto 8);

            -- Sender IP Address bytes 1 and 0

          when "00111" =>

            nextWrData <= own_IP_c( 23 downto 16 ) & own_IP_c (31 downto 24);

            -- Sender IP Address bytes 3 and 2

          when "01000" =>

            nextWrData <= own_IP_c( 7 downto 0 ) & own_IP_c (15 downto 8);

            -- Target Hardware Address bytes 1 and 0

          when "01001"            =>

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

            -- Target Hardware Address bytes 3 and 2

          when "01010"            =>

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

            -- Target Hardware Address bytes 5 and 4

          when "01011"            =>

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

            -- Target IP Address bytes 1 and 0

          when "01100" =>

            nextWrData <= IP_r( 23 downto 16 ) & IP_r (31 downto 24);

            -- Target IP Address bytes 3 and 2

          when "01101" =>

            nextWrData <= IP_r( 7 downto 0 ) & IP_r (15 downto 8);

          when others => null;

        end case;

        -- store the ARP reply for the Ethernet sender

      when stStoreARPRequest =>

        if wr_re_in = '1' then

          if cnt = "01101" then

            nextState <= stWaitForValidEntry;

            rstARPCnt <= '1';

          else

            nextState <= stGenARPRequest;

            incCnt    <= '1';

          end if;

        else

          nextState <= stStoreARPRequest;

        end if;

        -- wait for the ARP entry to become valid

      when stWaitForValidEntry =>

        -- if the ARP entry becomes valid then we fire off the reply

        if ARP_entry_valid_in = '1' then

          tx_ready_out   <= '1';

          nextState      <= stGiveMAC;

          latchTargetMAC <= '1';

          -- otherwise give a certain amount of time for the ARP reply to come

          -- back in (21.5 secs on a 50MHz clock)

        else

          -- if the reply doesn't come back, then inform the above layer that the

          -- frame was sent.  Assume the higher level protocol can account for this

          -- problem, or possibly an error signal could be created once a higher level

          -- protocol has been written that can accomodate this

          if ARP_cnt_overflow_r = '1' then

            nextState         <= stIdle;

          else

            nextState         <= stWaitForValidEntry;

          end if;

        end if;

        lookup_IP_out         <= IP_r;

      when stGiveMAC =>

        MAC_to_output <= '1';

        nextState     <= stIdle;

      when others => nextState <= stIdle;

    end case;

  end process;

end ARPSnd_arch;