Subversion Repositories nocem

 
-----------------------------------------------------------------------------
-- NoCem -- Network on Chip Emulation Tool for System on Chip Research 
-- and Implementations
-- 
-- Copyright (C) 2006  Graham Schelle, Dirk Grunwald
-- 
-- This program is free software; you can redistribute it and/or
-- modify it under the terms of the GNU General Public License
-- as published by the Free Software Foundation; either version 2
-- of the License, or (at your option) any later version.
-- 
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
-- 
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  
-- 02110-1301, USA.
-- 
-- The authors can be contacted by email: <schelleg,grunwald>@cs.colorado.edu 
-- 
-- or by mail: Campus Box 430, Department of Computer Science,
-- University of Colorado at Boulder, Boulder, Colorado 80309
-------------------------------------------------------------------------------- 
 
 
-- 
-- Filename: ap_exerciser_vc.vhd
-- 
-- Description: access point exerciser for VC designs
-- 
 
 
 
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
 
use work.pkg_nocem.all;
 
 
entity ap_exerciser_vc is
	Generic(
 
		DELAY_START_COUNTER_WIDTH 		: integer := 32;
		DELAY_START_CYCLES 				: integer := 500;
		PKT_LENGTH 							: integer := 5;
		INTERVAL_COUNTER_WIDTH 			: integer := 8;
		DATA_OUT_INTERVAL 				: integer := 16;
	   INIT_DEST_ADDR 					: integer := 0;
		MY_ADDR 								: integer := 0;
		EXERCISER_MODE						: integer := EXERCISER_MODE_SIM
		 )	;
    Port ( 
 
		-- arbitration lines (usage depends on underlying network)
		arb_req         : out  std_logic;
		arb_cntrl_out   : out  arb_cntrl_word;
 
		arb_grant         : in std_logic;
		arb_cntrl_in      : in  arb_cntrl_word;
 
		datain        : in   data_word;
		datain_valid  : in   std_logic;
		datain_recvd  : out  std_logic;
 
		dataout       : out data_word;
		dataout_valid : out std_logic;
		dataout_recvd : in  std_logic;
 
		pkt_cntrl_in        : in   pkt_cntrl_word;
		pkt_cntrl_in_valid  : in   std_logic;
		pkt_cntrl_in_recvd  : out  std_logic;      
 
		pkt_cntrl_out       : out pkt_cntrl_word;
		pkt_cntrl_out_valid : out std_logic;
		pkt_cntrl_out_recvd : in  std_logic;
 
		clk : in std_logic;
      rst : in std_logic		
 
		);
end ap_exerciser_vc;
 
architecture Behavioral of ap_exerciser_vc is
 
		signal rst_i : std_logic;
		signal rst_counter : std_logic_vector(DELAY_START_COUNTER_WIDTH-1 downto 0);
		signal interval_counter : std_logic_vector(INTERVAL_COUNTER_WIDTH-1 downto 0);
		signal dataout_reg : std_logic_vector(NOCEM_DW-1 downto 0);
		signal pkt_cntrl_out_reg : pkt_cntrl_word;
 
 
		signal burst_counter : std_logic_vector(7 downto 0);
 
		signal datain_reg : data_word;
		signal pkt_cntrl_in_reg : pkt_cntrl_word;
 
 
		type stateType is (init_st,sending_st,getting_vc_st);
		signal state,nextState : stateType;
 
		-- determine the next free outgoing VC
		signal next_free_vc  : std_logic_vector(NOCEM_NUM_VC-1 downto 0);
		signal vc_state : std_logic_Vector(NOCEM_NUM_VC-1 downto 0);   -- 0: free, 1: allocated --
		signal vc_allocate : std_logic;
		signal free_this_vc	 : std_logic_vector(NOCEM_NUM_VC-1 downto 0);
		signal vc_mux_wr_reg	 : std_logic_vector(NOCEM_VC_ID_WIDTH-1 downto 0);
 
 
		-- data gathering signals
		signal  next_vc_with_pkt,finished_pkt,eop_wr_sig,pkt_rdy	 : std_logic_vector(NOCEM_NUM_VC-1 downto 0);
		signal  recv_idle : std_logic;
 
		-- arbcntrl out signals used for ORing together
		signal  arb_sending_word,arb_receiving_word   :   arb_cntrl_word;
 
		signal allones_vcwidth : std_logic_vector(NOCEM_NUM_VC-1 downto 0);
 
		-- any debug signals
		signal  debug_vc_mux_wr	: std_logic_vector(NOCEM_VC_ID_WIDTH-1 downto 0);
 
 
begin
 
allones_vcwidth <= (others => '1');
 
-- arbcntrl out signals used for ORing together
arb_cntrl_out <= arb_sending_word or arb_receiving_word;
 
 
rst_gen : process (clk,rst)
begin 
	if rst='1' then
		rst_i <= '1';
		rst_counter <= (others => '0');
	elsif clk'event and clk ='1' then	
		rst_counter <= rst_counter+1;
		if rst_counter = DELAY_START_CYCLES then
				 rst_i <= '0';
		end if;	
	end if;
end process;
 
 
----------------------------------------------------------------------------------
--------KEEPING TRACK OF OUTGOING VC STATES --------------------------------------
----------------------------------------------------------------------------------
 
gen_vc_status_uclkd : process (vc_state)
begin
 
end process;
 
gen_vc_status_clkd : process (clk,rst)
begin
 
 
	if rst='1' then
		--next_free_vc <= ('1',others => '0');	
		vc_state <= (others => '0');
		free_this_vc <= (others => '0');	
		next_free_vc <= (others => '0');
	elsif clk'event and clk='1' then
 
 
		l2: for I in NOCEM_NUM_VC-1 downto 0 loop
			if vc_state(I) = '0' then
				next_free_vc <= CONV_STD_LOGIC_VECTOR(2**I,NOCEM_NUM_VC);
			end if;											  	
		end loop;
 
		if vc_state = allones_vcwidth then
			next_free_vc <= (others => '0');
		end if;
 
 
	    free_this_vc <= arb_cntrl_in(NOCEM_ARB_CNTRL_VC_EOP_RD_HIX downto NOCEM_ARB_CNTRL_VC_EOP_RD_LIX);
 
		 -- 0: free, 1: allocated --
		 l1: for I in NOCEM_NUM_VC-1 downto 0 loop
		 	if vc_state(I) = '0' and next_free_vc(I) = '1' and vc_allocate = '1' then -- free going to allocated
				vc_state(I) <= '1';
			elsif vc_state(I) = '1' and free_this_vc(I) = '1' then -- allocated going to free
				vc_state(I) <= '0';
			end if;		 
		 end loop;
 
	end if;
end process;
 
----------------------------------------------------------------------------------
----------------------------------------------------------------------------------
----------------------------------------------------------------------------------
 
 
dataout_gen_clkd : process (clk,rst_i,nextState)
begin
	if rst_i = '1' then
		 state <= init_st;
		 interval_counter		<= (others => '0');
		 dataout_reg		   <= (others => '0');
		 vc_mux_wr_reg		   <= (others => '0');
		 -- setup pkt_cntrl correctly
		 pkt_cntrl_out_reg <= (others => '0');
		 pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX)	<=  addr_gen(INIT_DEST_ADDR,NOCEM_NUM_ROWS,NOCEM_NUM_COLS,NOCEM_AW); 
 
 
		 burst_counter       <= (others => '0');
	elsif clk'event and clk='1' then
		state <= nextState;
   	case state is
      	when init_st =>
				 interval_counter		<= interval_counter+1;
				 --dataout_reg		   <= (others => '0');
--				 pkt_cntrl_out_reg(NOCEM_PKTCNTRL_SOP_IX)	<= '1'; 
--				 
--				 if PKT_LENGTH = 1 then
--				 	pkt_cntrl_out_reg(NOCEM_PKTCNTRL_EOP_IX)	<= '1';	
--				 else
--				 	pkt_cntrl_out_reg(NOCEM_PKTCNTRL_EOP_IX)	<= '0';
--				 end if;				 
				 vc_mux_wr_reg <= (others => '0');
 
 
 
 
				 burst_counter       <= (others => '0');
 
			when getting_vc_st =>
				--pkt_cntrl_out_reg <= (others => '0');
				interval_counter <= (others => '0');
				vc_mux_wr_reg <= next_free_vc;
			when sending_st =>
				-- marking packets with src addrs...
				dataout_reg(NOCEM_DW-1 downto NOCEM_AW) <= dataout_reg(NOCEM_DW-1 downto NOCEM_AW) + 1;
				dataout_reg(NOCEM_AW-1 downto 0)        <= addr_gen(MY_ADDR,NOCEM_NUM_ROWS,NOCEM_NUM_COLS,NOCEM_AW);
 
				-- handle the pkt_control reg
 
				-- increment the data inside
				if arb_grant = '1' and dataout_recvd = '1' then
					burst_counter <= 	burst_counter + 1;
				end if;
 
				if nextState = init_st then
 
					-- increment destination field (making sure it doesn't send a packet to myself)				 
					if pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX)+1 = addr_gen(MY_ADDR,NOCEM_NUM_ROWS,NOCEM_NUM_COLS,NOCEM_AW) then
							pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX) <= pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX) + 2;
					else
							pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX) <= pkt_cntrl_out_reg(NOCEM_PKTCNTRL_DEST_ADDR_HIX downto NOCEM_PKTCNTRL_DEST_ADDR_LIX) + 1;
					end if;	
				end if;
 
 
 
			when others =>
				null;
		end case;
	end if;
end process;
 
 
dataout_gen_uclkd : process (next_free_vc, vc_mux_wr_reg,pkt_cntrl_out_reg, pkt_cntrl_out_recvd,state, interval_counter, dataout_reg, arb_grant, dataout_recvd, burst_counter)
begin
 
		 arb_req	 <= '0';
		 arb_sending_word <= (others => '0');
		 dataout	 <= (others => '0');
		 dataout_valid	 <= '0';
		 --nextState <= init_st;
 
		 pkt_cntrl_out	 <= (others => '0');
		 pkt_cntrl_out_valid <= '0';
		 vc_allocate <= '0';
 
		case state is
      	when init_st =>
 
					if interval_counter = CONV_STD_LOGIC_VECTOR(DATA_OUT_INTERVAL,INTERVAL_COUNTER_WIDTH) then					
						nextState <= getting_vc_st;
					else
						nextState <= init_st;						
					end if;
 
			when getting_vc_st =>
 
				if next_free_vc /= 0 then
					vc_allocate <= '1';
					nextState <= sending_st;
				else
					nextState <= getting_vc_st;
				end if;			
 
 
			when sending_st =>
 
				arb_req <= '1';
				arb_sending_word(NOCEM_ARB_CNTRL_VC_MUX_WR_HIX downto NOCEM_ARB_CNTRL_VC_MUX_WR_LIX) <= vc_mux_wr_reg;
 
				dataout <= dataout_reg;
				dataout_valid <= '1';
 
				pkt_cntrl_out <= pkt_cntrl_out_reg;
				pkt_cntrl_out_valid <= '1';
 
 
				if burst_counter = 0 then
					pkt_cntrl_out(NOCEM_PKTCNTRL_SOP_IX)	<= '1';	
				end if;
 
				if burst_counter = PKT_LENGTH then
					pkt_cntrl_out(NOCEM_PKTCNTRL_EOP_IX)	<= '1';
		 			nextState <= init_st;				
				else
		 			nextState <= sending_st;				
				end if;
 
			when others =>
				null;
		end case;
end process;
 
 
 
----------------------------------------------------
----------------------------------------------------
-----------      DATAIN SIGNALLING     -------------
----------------------------------------------------
----------------------------------------------------
 
vc_datain_st_gen_clkd : process(clk,rst,arb_cntrl_in)
begin
 
	eop_wr_sig <= arb_cntrl_in(NOCEM_ARB_CNTRL_VC_EOP_WR_HIX downto NOCEM_ARB_CNTRL_VC_EOP_WR_LIX);
 
	if rst='1' then
		pkt_rdy <= (others => '0');
		next_vc_with_pkt <= (others => '0');
		datain_reg <= (others => '0');
		pkt_cntrl_in_reg <= (others => '0');
		recv_idle <= '1';
	elsif clk'event and clk='1' then
 
 
		l1: for I in NOCEM_NUM_VC-1 downto 0 loop
 
			-- is the pkt rdy for reading?
			if eop_wr_sig(I) = '1' then
				pkt_rdy(I) <= '1';
			elsif finished_pkt(I) = '1' then
				pkt_rdy(I) <= '0';			
			end if;	
 
			-- what is the next pkt to read from VCs?
			if pkt_rdy(I) = '1' and recv_idle = '1' then
				next_vc_with_pkt <= CONV_STD_LOGIC_VECTOR(2**I,NOCEM_NUM_VC);
				recv_idle <= '0';
			elsif finished_pkt /= 0 then
				recv_idle <= '1';	
			end if;
 
		end loop;
 
		if pkt_rdy = 0 then
			next_vc_with_pkt <= (others => '0');
		end if;
 
 
	end if;
 
end process;
 
 
 
datain_gather_uclkd : process (next_vc_with_pkt, pkt_cntrl_in,datain_valid,pkt_cntrl_in_valid)
begin
 
	datain_recvd <= '0';
	pkt_cntrl_in_recvd <= '0';
	finished_pkt <= (others => '0');
	arb_receiving_word <= (others => '0');
 
 
  	if next_vc_with_pkt /= 0 then
		arb_receiving_word(NOCEM_ARB_CNTRL_VC_MUX_RD_HIX downto NOCEM_ARB_CNTRL_VC_MUX_RD_LIX) <= next_vc_with_pkt;
		datain_recvd <= '1';	
	end if;
 
  	if next_vc_with_pkt /= 0 then
		pkt_cntrl_in_recvd <= '1';	
		if pkt_cntrl_in(NOCEM_PKTCNTRL_EOP_IX)	= '1' then
			finished_pkt <= next_vc_with_pkt;
		end if;			
	end if;
 
 
end process;
 
 
 
debug_gen : process (arb_sending_word)
begin
 
	debug_vc_mux_wr <= arb_sending_word(NOCEM_ARB_CNTRL_VC_MUX_WR_HIX downto NOCEM_ARB_CNTRL_VC_MUX_WR_LIX);
 
end process;
 
 
 
end Behavioral;