Subversion Repositories udp_ip_stack

----------------------------------------------------------------------------------
-- Company: 
-- Engineer:            Peter Fall
-- 
-- Create Date:    12:00:04 05/31/2011 
-- Design Name: 
-- Module Name:    arp_tx - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description:
--              handle transmission of an ARP packet.
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created - refactored this arp_tx module from the complete arp v0.02 module
-- Additional Comments: 
--
----------------------------------------------------------------------------------
  library IEEE;
use IEEE.STD_LOGIC_1164.all;
use IEEE.NUMERIC_STD.all;
use work.arp_types.all;
 
entity arp_tx is
  port (
    -- control signals
    send_I_have     : in  std_logic;    -- pulse will be latched
    arp_entry       : in  arp_entry_t;  -- arp target for I_have req (will be latched)
    send_who_has    : in  std_logic;    -- pulse will be latched
    ip_entry        : in  std_logic_vector (31 downto 0);  -- IP target for who_has req (will be latched)
    -- MAC layer TX signals
    mac_tx_req      : out std_logic;  -- indicates that ip wants access to channel (stays up for as long as tx)
    mac_tx_granted  : in  std_logic;  -- indicates that access to channel has been granted            
    data_out_ready  : in  std_logic;    -- indicates system ready to consume data
    data_out_valid  : out std_logic;    -- indicates data out is valid
    data_out_first  : out std_logic;  -- with data out valid indicates the first byte of a frame
    data_out_last   : out std_logic;  -- with data out valid indicates the last byte of a frame
    data_out        : out std_logic_vector (7 downto 0);  -- ethernet frame (from dst mac addr through to last byte of frame)
    -- system signals
    our_mac_address : in  std_logic_vector (47 downto 0);
    our_ip_address  : in  std_logic_vector (31 downto 0);
    tx_clk          : in  std_logic;
    reset           : in  std_logic
    );
end arp_tx;
 
architecture Behavioral of arp_tx is
 
  type count_mode_t is (RST, INCR, HOLD);
  type set_clr_t is (SET, CLR, HOLD);
  type tx_state_t is (IDLE, WAIT_MAC, SEND);
  type tx_mode_t is (REPLY, REQUEST);
 
  -- state variables
  signal tx_mac_chn_reqd  : std_logic;
  signal tx_state         : tx_state_t;
  signal tx_count         : unsigned (7 downto 0);
  signal send_I_have_reg  : std_logic;
  signal send_who_has_reg : std_logic;
  signal I_have_target    : arp_entry_t;  -- latched target for "I have" request
  signal who_has_target   : std_logic_vector (31 downto 0);  -- latched IP for "who has" request
  signal tx_mode          : tx_mode_t;  -- what sort of tx to make
  signal target           : arp_entry_t;  -- target to send to
 
  -- busses
  signal next_tx_state : tx_state_t;
  signal tx_mode_val   : tx_mode_t;
  signal target_val    : arp_entry_t;
 
  -- tx control signals
  signal set_tx_state        : std_logic;
  signal tx_count_mode       : count_mode_t;
  signal set_chn_reqd        : set_clr_t;
  signal kill_data_out_valid : std_logic;
  signal set_send_I_have     : set_clr_t;
  signal set_send_who_has    : set_clr_t;
  signal set_tx_mode         : std_logic;
  signal set_target          : std_logic;
 
begin
 
  tx_combinatorial : process (
    -- input signals
    send_I_have, send_who_has, arp_entry, ip_entry, data_out_ready, mac_tx_granted,
    our_mac_address, our_ip_address, reset,
    -- state variables
    tx_state, tx_count, tx_mac_chn_reqd, I_have_target, who_has_target,
    send_I_have_reg, send_who_has_reg, tx_mode, target,
    -- busses
    next_tx_state, tx_mode_val, target_val,
    -- control signals
    tx_count_mode, kill_data_out_valid, set_send_I_have, set_send_who_has,
    set_chn_reqd, set_tx_mode, set_target
    )
  begin
    -- set output followers
    mac_tx_req <= tx_mac_chn_reqd;
 
    -- set combinatorial output defaults
    data_out_first <= '0';
 
    case tx_state is
      when SEND =>
        if data_out_ready = '1' and kill_data_out_valid = '0' then
          data_out_valid <= '1';
        else
          data_out_valid <= '0';
        end if;
      when others => data_out_valid <= '0';
    end case;
 
    -- set bus defaults
    next_tx_state  <= IDLE;
    tx_mode_val    <= REPLY;
    target_val.ip  <= (others => '0');
    target_val.mac <= (others => '1');
 
    -- set signal defaults
    set_tx_state        <= '0';
    tx_count_mode       <= HOLD;
    data_out            <= x"00";
    data_out_last       <= '0';
    set_chn_reqd        <= HOLD;
    kill_data_out_valid <= '0';
    set_send_I_have     <= HOLD;
    set_send_who_has    <= HOLD;
    set_tx_mode         <= '0';
    set_target          <= '0';
 
    -- process requests in regardless of FSM state
    if send_I_have = '1' then
      set_send_I_have <= SET;
    end if;
    if send_who_has = '1' then
      set_send_who_has <= SET;
    end if;
 
    -- TX FSM
    case tx_state is
      when IDLE =>
        tx_count_mode <= RST;
        if send_I_have_reg = '1' then
          set_chn_reqd    <= SET;
          tx_mode_val     <= REPLY;
          set_tx_mode     <= '1';
          target_val      <= I_have_target;
          set_target      <= '1';
          set_send_I_have <= CLR;
          next_tx_state   <= WAIT_MAC;
          set_tx_state    <= '1';
        elsif send_who_has_reg = '1' then
          set_chn_reqd     <= SET;
          tx_mode_val      <= REQUEST;
          set_tx_mode      <= '1';
          target_val.ip    <= who_has_target;
          target_val.mac   <= (others => '1');
          set_target       <= '1';
          set_send_who_has <= CLR;
          next_tx_state    <= WAIT_MAC;
          set_tx_state     <= '1';
        else
          set_chn_reqd <= CLR;
        end if;
 
      when WAIT_MAC =>
        tx_count_mode <= RST;
        if mac_tx_granted = '1' then
          next_tx_state <= SEND;
          set_tx_state  <= '1';
        end if;
        -- TODO - should handle timeout here
 
      when SEND =>
        if data_out_ready = '1' then
          tx_count_mode <= INCR;
        end if;
        case tx_count is
          when x"00" => data_out_first <= data_out_ready;
                        data_out <= target.mac (47 downto 40);       -- target mac--data_out       <= x"ff";    -- dst = broadcast            
          when x"01" => data_out <= target.mac (39 downto 32);                    --data_out <= x"ff";
          when x"02" => data_out <= target.mac (31 downto 24);                    --data_out <= x"ff";
          when x"03" => data_out <= target.mac (23 downto 16);                    --data_out <= x"ff";
          when x"04" => data_out <= target.mac (15 downto 8);                     --data_out <= x"ff";
          when x"05" => data_out <= target.mac (7 downto 0);                      --data_out <= x"ff";
          when x"06" => data_out <= our_mac_address (47 downto 40);  -- src = our mac
          when x"07" => data_out <= our_mac_address (39 downto 32);
          when x"08" => data_out <= our_mac_address (31 downto 24);
          when x"09" => data_out <= our_mac_address (23 downto 16);
          when x"0a" => data_out <= our_mac_address (15 downto 8);
          when x"0b" => data_out <= our_mac_address (7 downto 0);
          when x"0c" => data_out <= x"08";                           -- pkt type = 0806 : ARP
          when x"0d" => data_out <= x"06";
          when x"0e" => data_out <= x"00";                           -- HW type = 0001 : eth
          when x"0f" => data_out <= x"01";
          when x"10" => data_out <= x"08";                           -- protocol = 0800 : ip
          when x"11" => data_out <= x"00";
          when x"12" => data_out <= x"06";                           -- HW size = 06
          when x"13" => data_out <= x"04";                           -- prot size = 04
 
          when x"14" => data_out <= x"00";  -- opcode =             
          when x"15" =>
            if tx_mode = REPLY then
              data_out <= x"02";            -- 02 : REPLY
            else
              data_out <= x"01";            -- 01 : REQ
            end if;
 
          when x"16" => data_out <= our_mac_address (47 downto 40);  -- sender mac
          when x"17" => data_out <= our_mac_address (39 downto 32);
          when x"18" => data_out <= our_mac_address (31 downto 24);
          when x"19" => data_out <= our_mac_address (23 downto 16);
          when x"1a" => data_out <= our_mac_address (15 downto 8);
          when x"1b" => data_out <= our_mac_address (7 downto 0);
          when x"1c" => data_out <= our_ip_address (31 downto 24);   -- sender ip
          when x"1d" => data_out <= our_ip_address (23 downto 16);
          when x"1e" => data_out <= our_ip_address (15 downto 8);
          when x"1f" => data_out <= our_ip_address (7 downto 0);
          when x"20" => data_out <= target.mac (47 downto 40);       -- target mac
          when x"21" => data_out <= target.mac (39 downto 32);                    
          when x"22" => data_out <= target.mac (31 downto 24);                    
          when x"23" => data_out <= target.mac (23 downto 16);                    
          when x"24" => data_out <= target.mac (15 downto 8);                     
          when x"25" => data_out <= target.mac (7 downto 0);                      
          when x"26" => data_out <= target.ip (31 downto 24);        -- target ip
          when x"27" => data_out <= target.ip (23 downto 16);
          when x"28" => data_out <= target.ip (15 downto 8);
 
          when x"29" =>
            data_out      <= target.ip(7 downto 0);
            data_out_last <= '1';
 
          when x"2a" =>
            kill_data_out_valid <= '1';  -- data is no longer valid
            next_tx_state       <= IDLE;
            set_tx_state        <= '1';
 
          when others =>
            next_tx_state <= IDLE;
            set_tx_state  <= '1';
        end case;
    end case;
  end process;
 
  tx_sequential : process (tx_clk)
  begin
    if rising_edge(tx_clk) then
      if reset = '1' then
        -- reset state variables
        tx_state          <= IDLE;
        tx_count          <= (others => '0');
        tx_mac_chn_reqd   <= '0';
        send_I_have_reg   <= '0';
        send_who_has_reg  <= '0';
        who_has_target    <= (others => '0');
        I_have_target.ip  <= (others => '0');
        I_have_target.mac <= (others => '0');
        target.ip         <= (others => '0');
        target.mac        <= (others => '1');
 
      else
        -- normal (non reset) processing
 
        -- Next tx_state processing
        if set_tx_state = '1' then
          tx_state <= next_tx_state;
        else
          tx_state <= tx_state;
        end if;
 
        -- input request latching
        case set_send_I_have is
          when SET =>
            send_I_have_reg <= '1';
            I_have_target   <= arp_entry;
          when CLR =>
            send_I_have_reg <= '0';
            I_have_target   <= I_have_target;
          when HOLD =>
            send_I_have_reg <= send_I_have_reg;
            I_have_target   <= I_have_target;
        end case;
 
        case set_send_who_has is
          when SET =>
            send_who_has_reg <= '1';
            who_has_target   <= ip_entry;
          when CLR =>
            send_who_has_reg <= '0';
            who_has_target   <= who_has_target;
          when HOLD =>
            send_who_has_reg <= send_who_has_reg;
            who_has_target   <= who_has_target;
        end case;
 
        -- tx mode
        if set_tx_mode = '1' then
          tx_mode <= tx_mode_val;
        else
          tx_mode <= tx_mode;
        end if;
 
        -- target latching
        if set_target = '1' then
          target <= target_val;
        else
          target <= target;
        end if;
 
        -- tx_count processing
        case tx_count_mode is
          when RST =>
            tx_count <= x"00";
          when INCR =>
            tx_count <= tx_count + 1;
          when HOLD =>
            tx_count <= tx_count;
        end case;
 
        -- control access request to mac tx chn
        case set_chn_reqd is
          when SET  => tx_mac_chn_reqd <= '1';
          when CLR  => tx_mac_chn_reqd <= '0';
          when HOLD => tx_mac_chn_reqd <= tx_mac_chn_reqd;
        end case;
 
      end if;
    end if;
  end process;
 
 
end Behavioral;