Subversion Repositories esoc

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

--

-- This VHDL file was generated by EASE/HDL 7.4 Revision 4 from HDL Works B.V.

--

-- Ease library  : work

-- HDL library   : work

-- Host name     : S212065

-- User name     : df768

-- Time stamp    : Tue Aug 19 08:05:18 2014

--

-- Designed by   : L.Maarsen

-- Company       : LogiXA

-- Project info  : eSoC

--

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

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

-- Object        : Entity work.esoc_search_engine_sa

-- Last modified : Tue Aug 19 08:05:17 2014.

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

library ieee, std, work;

use ieee.std_logic_1164.all;

use std.textio.all;

use ieee.numeric_std.all;

use work.package_hash10_24b.all;

use work.package_esoc_configuration.all;

entity esoc_search_engine_sa is

  port(

    clk_search                : in     std_logic;

    reset                     : in     std_logic;

    search_aging_tick         : in     std_logic;

    search_entry_age_time     : in     std_logic_vector(11 downto 0);

    search_entry_age_time_ena : in     std_logic;

    search_sa_drop_cnt        : out    std_logic;

    search_sa_store_empty     : in     std_logic;

    search_sa_store_q         : in     std_logic_vector(79 downto 0);

    search_sa_store_rd        : out    std_logic;

    search_sa_store_words     : in     STD_LOGIC_VECTOR(6 downto 0);

    search_table_address      : out    STD_LOGIC_VECTOR(12 downto 0);

    search_table_data         : out    STD_LOGIC_VECTOR(79 downto 0);

    search_table_q            : in     STD_LOGIC_VECTOR(79 downto 0);

    search_table_rden         : out    STD_LOGIC;

    search_table_wren         : out    STD_LOGIC);

end entity esoc_search_engine_sa;

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

-- Object        : Architecture work.esoc_search_engine_sa.esoc_search_engine_sa

-- Last modified : Tue Aug 19 08:05:17 2014.

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

architecture esoc_search_engine_sa of esoc_search_engine_sa is

type   search_states is (idle, wait_sa, wait_hash, compare, add);

signal search_state: search_states;

type   aging_states is (idle, wait_empty, wait_entry, evaluate);

signal aging_state: aging_states;

signal search_table_address_i: std_logic_vector(search_table_address'high downto 0);

signal search_hash_delay_cnt: integer range esoc_search_engine_hash_delay downto 0;

signal search_table_coll_cnt: integer range esoc_search_engine_col_depth downto 0;

signal search_table_free_entry_os: integer range esoc_search_engine_col_depth downto 0;

signal search_table_free_entry: std_logic;

signal search_key_i: std_logic_vector(search_table_data'high downto 0);

signal aging_count_down: integer range 2**search_entry_age_time'length-1 downto 0;

signal aging_address: integer range 2**search_table_address'length-1 downto 0;

begin

--=============================================================================================================

-- Process                : proces search requests for source MAC address

-- Description  : 

--=============================================================================================================    

search_sa:  process(clk_search, reset)

            begin

              if reset = '1' then

                search_table_free_entry     <= '0';

                search_table_free_entry_os  <= 0;

                search_table_coll_cnt       <= 0;

                search_hash_delay_cnt       <= 0;

                search_sa_drop_cnt          <= '0';

                search_table_rden           <= '0';

                search_table_wren           <= '0';

                search_sa_store_rd          <= '0';

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

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

                search_state                <= idle;

                aging_state                 <= idle;

                aging_address               <= 0;

                aging_count_down            <= 0;

              elsif clk_search'event and clk_search = '1' then

                -- clear one-clock active signals

                search_sa_drop_cnt <= '0';

                search_table_rden  <= '0';

                search_table_wren  <= '0';

                search_sa_store_rd <= '0';

                --

                -- process new search requests 

                --

                case search_state is

                  when idle       =>  -- get Source Port + SA and calculate hash pointer (additional delay may be required after synthesis, due to large XOR tree)  

                                      if search_sa_store_empty = '0' then

                                        search_key_i                <= search_sa_store_q;

                                        search_table_address_i      <= CALC_HASH10_24b(search_sa_store_q(esoc_search_bus_mac+23 downto esoc_search_bus_mac)) & "000";

                                        search_table_rden           <= '1';

                                        search_table_free_entry     <= '0';

                                        search_table_free_entry_os  <= 0;

                                        search_table_coll_cnt       <= 0;

                                        -- use delay mechanism to give the hash function - large xor tree - time to provide stable result

                                        -- depends on target speed, use target timing analysis result to optimze this delay! At least one clock

                                        -- delay due to RAM latency

                                        search_hash_delay_cnt <= esoc_search_engine_hash_delay-1;

                                        search_state          <= wait_hash;

                                        search_sa_store_rd <= '1';

                                      end if;

                  when wait_hash  =>  -- hash result stable?  

                                      if search_hash_delay_cnt = 0 then

                                        search_table_address_i  <= std_logic_vector(to_unsigned(to_integer(unsigned(search_table_address_i))+1,search_table_address_i'length));

                                        search_state <= compare;

                                      else

                                        search_hash_delay_cnt <= search_hash_delay_cnt-1;

                                      end if;

                                      search_table_rden           <= '1';

                  when compare  => -- there is a hit on SA and VID and the entry is valid

                                   if search_table_q(esoc_search_entry_vlan+11 downto esoc_search_entry_vlan) = search_key_i(esoc_search_entry_vlan+11 downto esoc_search_entry_vlan) and

                                     search_table_q(esoc_search_entry_mac+47 downto esoc_search_entry_mac)   = search_key_i(esoc_search_entry_mac+47 downto esoc_search_entry_mac)   and

                                     search_table_q(esoc_search_entry_valid) = '1' then

                                    search_table_address_i                 <= std_logic_vector(to_unsigned(to_integer(unsigned(search_table_address_i))-1,search_table_address_i'length));

                                    search_key_i(esoc_search_entry_valid)  <= '1';

                                    search_key_i(esoc_search_entry_aging) <= '1';

                                    search_table_wren                      <= '1';

                                    search_state                           <= idle;

                                  -- there is no hit on SA and VID

                                  else

                                    -- end of collission buffer not reached, prepare for next entry

                                    if search_table_coll_cnt < esoc_search_engine_col_depth then

                                      -- is the current entry empty, remember position to use it when end of collission buffer is reached without a hit

                                      if search_table_free_entry = '0' and search_table_q(esoc_search_entry_valid) = '0' then

                                        search_table_free_entry <= '1';

                                      elsif search_table_free_entry = '0' then

                                        search_table_free_entry_os <= search_table_free_entry_os + 1;

                                      end if;

                                      search_table_coll_cnt   <= search_table_coll_cnt + 1;

                                      search_table_address_i  <= std_logic_vector(to_unsigned(to_integer(unsigned(search_table_address_i))+1,search_table_address_i'length));

                                      search_table_rden       <= '1';

                                    -- end of collission buffer without a hit, check previous empty entries were found or that last entry is empty else report full collission buffer

                                    else

                                      -- previous entry of collission buffer was empty, use it to store new SA + VID

                                      if search_table_free_entry = '1' then

                                        search_table_address_i <= std_logic_vector(to_unsigned(to_integer(unsigned(search_table_address_i))-esoc_search_engine_col_depth+search_table_free_entry_os-1,search_table_address_i'length));

                                        search_table_wren      <= '1';

                                      -- no previous empty entries, if last entry of collission buffer is empty, use it to store new SA + VID

                                      elsif search_table_q(esoc_search_entry_valid) = '0' then

                                        search_table_address_i <= std_logic_vector(to_unsigned(to_integer(unsigned(search_table_address_i))-1,search_table_address_i'length));

                                        search_table_wren <= '1';

                                      -- no entry of collission buffer is empty, no space to store new SA + VID  

                                      else

                                        search_sa_drop_cnt <= '1';

                                      end if;

                                      search_key_i(esoc_search_entry_valid)  <= '1';

                                      search_key_i(esoc_search_entry_aging) <= '1';

                                      search_state <= idle;

                                    end if;

                                  end if;

                  when others =>  search_state <= idle;

                end case;

                --

                -- process aging cycles

                --

                if search_aging_tick = '1' then

                  -- create aging timer based upon aging time setting register

                  if aging_count_down = 0 then

                    aging_count_down <= to_integer(unsigned(search_entry_age_time))+1;

                  else

                    aging_count_down <= aging_count_down - 1;

                  end if;

                end if;

                case aging_state is

                  when idle       =>  -- start aging cycle when aging mechanism is enabled and timer expires

                                      if aging_count_down = 0 and search_entry_age_time_ena = '1' then

                                        aging_address <= 0;

                                        aging_state   <= wait_empty;

                                      end if;

                  when wait_empty =>  -- wait for access to table with learned address (SA Search request first!)

                                      -- provide access when table is free for aging process

                                      if search_sa_store_empty = '1' and search_state = idle then

                                        search_table_address_i <= std_logic_vector(to_unsigned(aging_address,search_table_address_i'length));

                                        search_table_rden      <= '1';

                                        aging_state            <= wait_entry;

                                      end if;

                  when wait_entry =>  -- if table is still free prepare for entry evaluation else return to wait for access

                                      if search_sa_store_empty = '0' then

                                        aging_state <= wait_empty;

                                      else

                                        aging_state <= evaluate;

                                      end if;

                  when evaluate   =>  -- if table is still free update entry and increment address pointer else return to wait for access

                                      if search_sa_store_empty = '0' then

                                        aging_state <= wait_empty;

                                      else

                                        -- update the entry or even invalidate the entry

                                        if search_table_q(esoc_search_entry_valid) = '1' then

                                          search_key_i <= search_table_q;

                                          search_key_i(esoc_search_entry_valid)  <= search_table_q(esoc_search_entry_aging);

                                          search_key_i(esoc_search_entry_aging) <= '0';

                                          search_table_wren      <= '1';

                                        end if;

                                        -- update address pointer to process next entry

                                        if aging_address = 2**search_table_address_i'length - 1 then

                                          aging_state <= idle;

                                        else

                                          aging_address <= aging_address + 1;

                                          aging_state <= wait_empty;

                                        end if;

                                      end if;

                  when others     =>  aging_state <= idle;

                end case;

              end if;

            end process;

            search_table_address <= search_table_address_i;

            search_table_data    <= search_key_i;

end architecture esoc_search_engine_sa ; -- of esoc_search_engine_sa