-- GM (AN) LUCIANA GENOVESE
-- Design ed implementazione di un mini - router sincrono
-- File sorgente

-- -------------------------
-- Libreria
-- -------------------------
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;
use IEEE.numeric_std.all;


-- -------------------------
-- Entity 
-- -------------------------
entity mini_router is
   port (
         clk       : in  std_logic; 
         reset     : in  std_logic; -- Reset asincrono attivo basso
		 data1     : in  std_logic_vector(9 downto 0); 
		 req1      : in  std_logic; 
		 grant1    : out std_logic;
         data2     : in  std_logic_vector(9 downto 0); 
		 req2      : in  std_logic; 
		 grant2    : out std_logic;
		 data_out  : out std_logic_vector(7 downto 0); 
		 valid     : out std_logic
        );
end entity;
  
  
-- -------------------------
-- Architecture 
-- -------------------------	
architecture arch of mini_router is  

-- Segnale per controllo req
   signal request    : std_logic_vector (1 downto 0);  
  
-- Segnali per controllo bit di parità
   signal a          : std_logic; -- '1' se A < B altrimenti '0'
   signal b          : std_logic; -- '1' se A = B altrimenti '0'  
   signal c          : std_logic; -- '1' se A > B altrimenti '0'
  
-- Segnale per applicazione dell'algoritmo Round Robin
   signal r          : std_logic; 
   

-- Comparatore per controllo sui bit di parità  
  component comparator is
     port (
            A           : in std_logic_vector(1 downto 0); 
            B           : in std_logic_vector(1 downto 0); 
            A_less_B    : out std_logic; 
            A_equal_B   : out std_logic;
            A_greater_B : out std_logic			
          );
   end component;
  
 
 begin
  request <= req1&req2;
  
   COMPARATORE: comparator
    port map ( 
      A           => data1 (1 downto 0),
      B           => data2 (1 downto 0),
      A_less_B    => a,
      A_equal_B   => b,
      A_greater_B => c
	         );
 
 mini_router: process(clk,reset)
  
 begin

   if reset = '0' then
       data_out    <= (others => '0');
	   grant1      <= '0';
	   grant2      <= '0';   
	   valid       <= '0';
	   r           <= '0';
       
	   
   elsif rising_edge(clk) then
   
 -- Un solo req è alto
      if request = "10" then 
	  
	     data_out <= data1(9 downto 2);
         grant1   <= '1';
	     grant2   <= '0';
	     valid    <= '1';
	
	 elsif request = "01" then 
  
         data_out <= data2(9 downto 2);
         grant1   <= '0';
	     grant2   <= '1';
	     valid    <= '1';

-- Entrambi i req sono bassi		
     elsif request = "00" then  
	 
		  data_out <= (others => '0');
		  grant1   <= '0';
	      grant2   <= '0';
	      valid    <= '0'; 
  
-- Entrambi i req sono alti  
	 elsif request = "11" then

-- Il link 1 ha maggiore priorità
        if c='1' then
		
           data_out  <= data1(9 downto 2);
           grant1    <= '1';
	       grant2    <= '0';
	       valid     <= '1';

-- Il link 2 ha maggiore priorità			
        elsif a='1' then
		
           data_out  <= data2(9 downto 2);
	       grant1    <= '0';
	       grant2    <= '1';
	       valid     <= '1';
 
 -- Data conflict
        elsif b='1' then  
		
-- Applicazione dell'algoritmo Round Robin
           if r = '0' then 
		   
              data_out  <= data1(9 downto 2);
              grant1    <= '1';
	          grant2    <= '0';
	          valid     <= '1';
              r         <= '1';
  
           else 
		   
              data_out  <= data2(9 downto 2);
		      grant1    <= '0';
	          grant2    <= '1';
	          valid     <= '1';
              r         <= '0';
			  
           end if;

        end if;

      end if; 
	
    end if; 
   
  end process;

end architecture;