Subversion Repositories ht_tunnel

//flow_control_l3.h
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is HyperTransport Tunnel IP Core.
 *
 * The Initial Developer of the Original Code is
 * Ecole Polytechnique de Montreal.
 * Portions created by the Initial Developer are Copyright (C) 2005
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Jean-Francois Belanger
 *   Ami Castonguay <acastong@grm.polymtl.ca>
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the Polytechnique HyperTransport Tunnel IP Core Source Code License 
 * (the  "PHTICSCL License", see the file PHTICSCL.txt), in which case the
 * provisions of PHTICSCL License are applicable instead of those
 * above. If you wish to allow use of your version of this file only
 * under the terms of the PHTICSCL License and not to allow others to use
 * your version of this file under the MPL, indicate your decision by
 * deleting the provisions above and replace them with the notice and
 * other provisions required by the PHTICSCL License. If you do not delete
 * the provisions above, a recipient may use your version of this file
 * under either the MPL or the PHTICSCL License."
 *
 * ***** END LICENSE BLOCK ***** */
 
#include "../core_synth/synth_datatypes.h"	
#include "../core_synth/constants.h"
 
#ifndef FLOW_CONTROL_L3_H
#define FLOW_CONTROL_L3_H
 
  	///State machine possible state list
	enum fc_state { 
		NOP_SENT, ///< Sending a nop
		FWD_CMD32_SENT,/**< Sending the first dword of command packet from the 
					 	  reordering of the other side of the tunnel*/
		FWD_CMD64_FIRST_SENT,///< Sending first dword packet (of a quad word packet) from reordering
		FWD_CMD64_SECOND_SENT,///< Sending second dword packet (of a quad word packet) from reordering
		NOP_SENT_IN_FWD,/**< Sending nop in the middle of transmission of data from
							reordering of the other side of the tunnel*/
		FWD_DATA_SENT, ///< Sending data from reordering of the other side of the tunnel
		CSR_CMD_SENT, ///< Sending a packet from CSR
		EH_CMD_SENT, ///< Sending a packet from the error handler
		USER_CMD32_SENT, ///< Sending a dword packet from user fifo
		USER_CMD64_FIRST_SENT,///< Sending first dword packet (of a quad word packet) from user fifo
		USER_CMD64_SECOND_SENT,///< Sending second dword packet (of a quad word packet) from user fifo
		USER_DATA_SENT, ///< Sending data from the User Interface data buffers
		CSR_DATA_SENT, ///< Sending data from the CSR
		ERROR_DATA_SENT, ///< Sending data from the Error Handler
		NOP_SENT_IN_USER,///< Sending nop in the middle of transmission of data from UI
		NOP_SENT_IN_CSR,///< Sending nop in the middle of transmission of data from CSR
		NOP_SENT_IN_EH,///< Sending nop in the middle of transmission of data from EH
		LDTSTOP_DISCONNECT,///< State where we end up when the link is stopped through LDTSTOP, *not retry mode*
#ifdef RETRY_MODE_ENABLED
		RETRY_SEND_DISCONNECT,///< Send disconnects NOP to initiate the retry sequence
		RETRY_WAIT_FOR_ACK,/**< After a retry disconnect, wait for the next node to send
			the it's RxNextPacketToAck value so that we know were to start the histor
			playback*/ 
		RETRY_CMD32_SENT,///< Sending a dword packet from history buffer
		RETRY_CMD64_FIRST_SENT,///< Sending first dword packet (of a quad word packet) from history buffer
		RETRY_CMD64_SECOND_SENT,///< Sending second dword packet (of a quad word packet) from history buffer
		RETRY_DATA_SENT,///< Sending data payload of a history packet
		RETRY_SEND_DISCONNECT_CRC,///< Sends the CRC associated with the disconnect nop
		RETRY_WAIT_FOR_RX_DISCONNECT,/**< Wait for RX to disconnect before attempting to
			reconnect TX */
		RETRY_WAIT_FOR_ACK_AND_BUFFER_COUNT_SENT,/**< After a retry disconnect, wait for
			the next node to send the it's RxNextPacketToAck value so that we know were
			to start the history playback.
 
			Retry also requires that we advertise at least the same amount of buffers then 
			we had before the retry sequence, so we also wait until all our free buffers
			have been advertised as free*/ 
		RETRY_WAIT_FOR_ACK_AND_BUFFER_COUNT_SENT_CRC,/**< When in the state
			RETRY_WAIT_FOR_ACK_AND_BUFFER_COUNT_SENT, we send nop.  Since we are in
			retry mode, we are also required to send the CRC's of the nop */
		RETRY_SEND_CMD_CRC,///< Send CRC of a history packet
		SEND_CMD_CRC,///< Send the CRC of a packet with no data associated
		SEND_NOP_CRC,///<Send the crc of a nop packet
		SEND_DATA_CRC,///< Send the CRC of a packet with data associated 
		NOP_CRC_SENT_IN_FWD,///< Send the CRC of a nop inserted in a FWD data transfer
		NOP_CRC_SENT_IN_USER,///<Send the CRC of a nop inserted in a UI data transfer
		NOP_CRC_SENT_IN_CSR,///< Send the CRC of a nop inserted in a CSR data transfer
		NOP_CRC_SENT_IN_EH,///< Send the CRC of a nop inserted in a EH data transfer
		RETRY_NOP_SENT,///< Send a nop while playing back history
		RETRY_NOP_CRC_SENT,///< Sending the CRC of a nop packet while playing back history
		RETRY_NOP_SENT_IN_DATA,/**< Send a nop while playing back history,
							   in the middle of a data packet*/
		RETRY_NOP_CRC_SENT_IN_DATA/**< Sending the CRC of a nop packet while 
								  playing back history, in the middle of a data packet*/
#endif
		};               
 
	//State values for storing if we are sending a chain
	enum fc_chain_state { NO_CHAIN_STATE,FWD_CHAIN_STATE,USER_CHAIN_STATE};
 
 
 
/// Finite state machine of the flow control
/**see flow_control_l2.h for explanation of the role of the flow_control*/
class flow_control_l3 : public sc_module
{
	public:
 
 
	//Signals to internal FIFO
	///If there is a packet that can be sent from the internal user fifo
    sc_in <bool> fifo_user_available ;
	///The packet to be sent from the user fifo
	sc_in <sc_bv<64> > fifo_user_packet;
	///The packet fifo_user_packet is being consumed
	sc_out<bool> consume_user_fifo;
	///Hold the packet so it doesn't change after sending the first dword
	sc_out<bool> hold_user_fifo;
 
	/**
		These signals are not necessary, but they are registered in the
		user_fifo to accelerate the combinatorial path of this module.
	*/
	//@{
	///Virtual channel of the ::fifo_user_packet
 	sc_in<VirtualChannel> fifo_user_packet_vc;
	///If ::fifo_user_packet is a double word packet (as opposed to a quad word, word = 16 bits)
	sc_in<bool> fifo_user_packet_dword;
	///If ::fifo_user_packet has any data associated
	sc_in<bool> fifo_user_packet_data_asociated;
#ifdef RETRY_MODE_ENABLED
    ///The command of fifo_user_packet
	sc_in<PacketCommand > fifo_user_packet_command;
#endif
    ///Size of ::fifo_user_packet data in dwords minus 1
	sc_in<bool> fifo_user_packet_isChain; 
    ///If ::fifo_user_packet has the chain bit on (also checks if it's a posted packet)
	sc_in<sc_uint<4> > fifo_user_packet_data_count_m1;
    //@}
 
	//Signals to error handler
 
	///If the error handler has a packet available to send
    sc_in <bool> eh_available_fc ;
	///Acknowledge that the packet from the error handler has been read
    sc_out <bool> fc_ack_eh;
	///The dword to be sent from the errorhandler
    sc_in <sc_bv<32> > eh_cmd_data_fc;
 
 
	//Signals to CSR
 
	///CSR has a packet to be sent
    sc_in <bool> csr_available_fc;
	///Acknowledge that the packet from the CSR has been read
    sc_out <bool> fc_ack_csr;		
	///The dword to be sent from the CSR
	sc_in <sc_bv<32> > csr_dword_fc;
 
 
	//Signals to Reordering
 
	///Reordering has a packet to be sent
    sc_in <bool> ro_available_fwd;
	///Reordering requests that a nop be sent to notify of free buffers
    sc_in <bool> ro_nop_req_fc;
	///Packt to send from reordering
    sc_in <syn_ControlPacketComplete> ro_packet_fwd;
	sc_in<VirtualChannel> ro_packet_vc_fwd;
	///To consume the data from the reordering_l2 module
	sc_out<bool> fwd_ack_ro;
 
	//Signals to User Interface
 
	///To read data from the userinterface buffers
	sc_out <bool> fc_consume_data_ui;
	///The virtual channel of the data to fetch from the user interface buffers
	sc_out<VirtualChannel> 		fc_data_vc_ui;
 
 
 
    //Signals from databuffer from other side  
 
	///Databuffer requests that a nop be sent to notify of free buffers
    sc_in <bool> db_nop_req_fc;
	///The address to read data from the databuffer from the other side
    sc_out <sc_uint<BUFFERS_ADDRESS_WIDTH> > fwd_address_db;
	///Read the data from the databuffer of the other side
    sc_out <bool> fwd_read_db;
	///The virtual channel to read data from the databuffer from the other side
    sc_out<VirtualChannel>  fwd_vctype_db;
 	///To erase the data packet
    sc_out <bool> fwd_erase_db;
 
	//Signals from nop_framer
 
	///The next packet to send should be a nop
    sc_in <bool> nop_next_to_send;
	///nophandler should generate disconnect nops
	sc_out<bool> generate_disconnect_nop;
	///If there are buffer to be notified as free with a nop
	sc_in<bool> has_nop_buffers_to_send;
 
	//Signals to fairness
 
	///If the local side has priority
	sc_in<bool> local_priority;
	///If a local packet is issued (can be sent or reserved to send when buffers available)
	sc_out<bool> local_packet_issued;
 
 
    //Signals to rx_farend_cnt
 
	///The VC of the packet currenlty being sent and if it has data (one hot encoding)
    sc_out <sc_bv<6> > current_sent_type; 
	///Status of the buffers of every VC's for command and data buffers
	/**Set if it has free buffer (one hot encoding)
		ResponseData	bit 0
		Response		bit 1
		NonPostData		bit 2
		NonPostCmd		bit 3
		PostData		bit 4	
		PostCmd			bit 5
	*/
    sc_in<sc_bv<6> > fwd_next_node_buffer_status_ro;
 
#ifdef RETRY_MODE_ENABLED
	///Clear the count of buffers for the next HT node to zero
	sc_out <bool>	clear_farend_count;
 
	//Misc signals
 
	///Link requests that we start a retry disconnect sequence
	sc_in  <bool> lk_initiate_retry_disconnect;
	///Force the link to disconnect
	/**Disconnect will occur after the current dword is done sending*/
    sc_out <bool> fc_disconnect_lk;
	///Command decoder requests that we start a retry disconnect sequence
	sc_in <bool> cd_initiate_retry_disconnect;
 
#endif
	//Signal to multiplexer
 
    ///Select which signal to send to link
    sc_out <sc_uint<4> > fc_ctr_mux;
 
 
	//Signals to link
 
	///LCTL output signal
    sc_out <bool> fc_lctl_lk;
	///HCTL output signal
    sc_out <bool> fc_hctl_lk;
	///For the link to consume data we send to it
    sc_in  <bool> lk_consume_fc;
#ifdef RETRY_MODE_ENABLED
	///If the RX part of the link is connected
	sc_in  <bool> lk_rx_connected;
#endif
 
 
	//Misc signals
 
	///If a nop is being sent to the link
    sc_out <bool> fc_nop_sent;
	///Reset
    sc_in <bool> resetx;
	///LDTSTOP# - Stop the transfer of data to save power
    sc_in <bool> ldtstopx;
	///Clock
    sc_in_clk clock;
 
	///Configuration register bit to turn the transmitter off
    //sc_in <bool> csr_transmitteroff;
	///A nop was just received - new ack value and new freed buffers value
	sc_in<bool>			nop_received;
 
#ifdef RETRY_MODE_ENABLED
	///If we are in retry mode
	sc_in<bool>			csr_retry;
 
 
	//History signals
 
	///Packet from the output of the history buffers
	sc_in <sc_bv<32> > history_packet;
 
	///Everything in the history buffers has bee played back
	sc_in <bool > history_playback_done;
	///When the history is ready to begin playback
	sc_in <bool > history_playback_ready;
	///Start to replay the content of the history buffer
	sc_out <bool > begin_history_playback;
	///Interrupt the replay of the content of the history buffer
	sc_out <bool > stop_history_playback;
	///To read the data from the history buffer
	sc_out <bool > consume_history;
 
	///The amount of dwords left in the history
	sc_in <bool > room_available_in_history;
 
	///Add a dword to the current history entry
	/**
		You must have created an history entry before entering dwords in it...
	*/
	sc_out <bool > add_to_history;
	///Start a new history entry (packet) of size new_history_entry_size_m1
	sc_out <bool > new_history_entry;
	///Size of the new history entry
	sc_out<sc_uint<5> > new_history_entry_size_m1;
 
 
	//Signals to CRC unit
 
	///Calculate the CRC on the current output to the link
	sc_out<bool>	calculate_crc;
	///Clear the current calculated CRC value
	sc_out<bool>	clear_crc;
	///Calculate the CRC on the current output to the link for nop packets
	sc_out<bool>	calculate_nop_crc;
	///Calculate the CRC on the current output to the link for nop packets
	sc_out<bool>	clear_nop_crc;
 
	///If we should output the current calculated CRC
	sc_out<bool>	select_crc_output;
	///If we should output the current calculated nop CRC
	sc_out<bool>	select_nop_crc_output;
 
 
	///Next value of ::fc_disconnect_lk
    sc_signal <bool> next_fc_disconnect_lk;
	///Next value of ::calculate_nop_crc
	sc_signal<bool>	next_calculate_nop_crc;
	///Next value of ::calculate_crc
	sc_signal<bool>	next_calculate_crc;
	///Next value of ::select_crc_output
	sc_signal<bool> next_select_crc_output;
	///Next value of ::select_nop_crc_output
	sc_signal<bool> next_select_nop_crc_output;
#endif
 
 
 	///Saved value of fwd_vctype_db
    sc_signal<VirtualChannel>  buffered_fwd_vctype_db;
 	///Saved value of fwd_address_db
    sc_signal <sc_uint<BUFFERS_ADDRESS_WIDTH> > buffered_fwd_address_db;
	///The next value fc_data_vc_ui will take
	sc_signal<VirtualChannel> 		buffered_fc_data_vc_ui;
	///Registered value of ::lk_rx_connected
	sc_signal<bool> registered_lk_rx_connected;
	///Registered value of ::registered_lk_initiate_retry_disconnect
	sc_signal<bool> registered_lk_initiate_retry_disconnect;
 
	//Buffer signals to link
 
	///LCTL output signal
    sc_signal<bool> next_fc_lctl_lk;
	///HCTL output signal
    sc_signal <bool> next_fc_hctl_lk;
 
	///Next value of next_data_cnt
    sc_signal<sc_uint<4> > next_data_cnt;
	///The number of dwords left to send all the data payload of a packet
    sc_signal<sc_uint<4> > data_cnt;
 
	///Next value of ::has_data
    sc_signal<bool > next_has_data;
	///If there is still data to be sent for the current packet
    sc_signal<bool > has_data;
 
	///Next value of chain_current_state
	sc_signal<fc_chain_state> next_chain_current_state;
	///The current state for sending posted packets that have chain bits
	/**	When sending a posted packet that has chain bit set, it means it is
		a chain of packets that cannot be seperated by inserting other posted
		packets, so we remember it by going in a chain state*/
    sc_signal<fc_chain_state> chain_current_state;
 
	///The next value curr_state will take (at rising edge of the clock)
    sc_signal <fc_state> next_state;
	///The current state of the flow_control_l3
    sc_signal <fc_state> curr_state;
 
#ifdef RETRY_MODE_ENABLED
	///Register to store that a retry disconnect has been initiated
	sc_signal<bool>		retry_disconnect_initiated;
	///To clear the retry_disconnect_initiated signal
	sc_signal<bool>		clear_retry_disconnect_initiated;
 
	///Register to store if we have received at least one ack (a nop packet) from
	//the other link
	/** It is important to wait for this to be set before replaying the history in
	a retry sequence, to be sure that we start playing back the history at the right
	position*/
	sc_signal<bool>		received_ack;
 
#endif
 
	///Register to reserve a local fairness spot for a VC
    sc_signal<bool> fairness_vc_reserved[3];
 	///next value of fairness_vc_reserved
    sc_signal<bool> next_fairness_vc_reserved[3];
 
	///Signals calculated by ::find_next_state()
	//@{
    sc_signal <fc_state> found_next_state;
	sc_signal<bool> found_load_fwd_pkt;
	sc_signal<bool> found_load_eh_pkt;
	sc_signal<bool> found_load_csr_pkt;
	sc_signal<bool> found_load_user_fifo_pkt;
	sc_signal<bool> found_hold_user_fifo_pkt;
	sc_signal<fc_chain_state> found_next_chain_current_state;
	sc_signal<sc_bv<6> > found_current_sent_type;
	sc_signal<sc_uint<4> > found_fc_ctr_mux;
	sc_signal<bool> found_generate_disconnect_nop;
	sc_signal<bool> found_fc_nop_sent;
	sc_signal<VirtualChannel> found_fwd_vctype_db;
	sc_signal<sc_uint<BUFFERS_ADDRESS_WIDTH> > found_fwd_address_db;
	sc_signal<sc_uint<4> > found_next_data_cnt;
	sc_signal<bool> found_next_has_data;
	sc_signal<VirtualChannel> found_fc_data_vc_ui;
	sc_signal<bool> found_local_packet_issued;
	sc_signal<bool> found_next_fairness_vc_reserved[3];
 
#ifdef RETRY_MODE_ENABLED
	sc_signal<sc_uint<5> > found_new_history_entry_size_m1;
	sc_signal<bool > found_new_history_entry;
	sc_signal<bool>	found_next_calculate_crc;
	sc_signal<bool>	found_next_calculate_nop_crc;
#endif
	//@}
 
#ifdef RETRY_MODE_ENABLED
 
	///Signals calculated by ::find_next_retry_state()
	//@{
	sc_signal<sc_uint<4> > foundh_fc_ctr_mux;
	sc_signal<bool>	foundh_fc_nop_sent;
	sc_signal<fc_state> foundh_next_state;
	sc_signal<bool>	foundh_next_fc_lctl_lk;
	sc_signal<bool>	foundh_next_fc_hctl_lk;
	sc_signal<bool>	foundh_next_calculate_nop_crc;
	sc_signal<bool>	foundh_next_calculate_crc;
	sc_signal<sc_uint<4> > foundh_next_data_cnt;
	sc_signal<bool>	foundh_next_has_data;
	sc_signal<sc_bv<6> > foundh_current_sent_type;
	sc_signal<bool>	foundh_consume_history;
	sc_signal<bool>	foundh_generate_disconnect_nop;
	//@}
 
#endif
 
 
   	///The clocked process for the state machine
   	void fc_fsm_state( void );
	///Finds the next state of the flow_control_l3
	void fc_fsm( void );
	///Verify that that type of packet can be sent to the other link
	/**
		@param vc The virtual channel to verify
		@param data If we are looking at the data buffers.  false for command buffers
		@return If a packet of VirtulChannel vc and that does (data==true) or 
			does not(data==false) can be sent to the next HT node.  The next HT node
			must have enough free buffers to accept the packet
	*/
  	bool verify_buffer_status (VirtualChannel vc , bool data);
	///Find the one hot encoded value of what packet type is being sent
	void set_found_sent_type (VirtualChannel vc , bool data);
	///Find the next state to go in when a new packet has to be sent (combinatory process)
	/** @description
		This part needs a bit of explaining.  The method find_next_state finds
		what is the next thing we need to do when not in a retry sequence and
		also finds the different outputs of the design.  It is called after a
		packet has finished being sent : we are ready so send a new packet.
 
		This needs to be done at multiple places in the code.  If the function
		is called directly from the state machine, during synthesis, the function
		will be embeded multiple times in the states machines.  Since the method
		is quite big, it really blows up the size of the final verilog or vhdl
		code, making it VERY long to synthesize afterwards.
 
		To cut back on this time, the method find_next_state is a combinatory process
		which set signals named found_*, then the state machine can calls ::set_next_state()
		to set the outputs to what was found in the next state.  This way, only the
		assignation is placed in the state machine during synthesis.
	*/
	void find_next_state();
	///Set what ::find_next_state() has found
	void set_next_state();
 
 
	///Methods to go to specific state while also setting correct outputs
	//@{
	void go_NOP_SENT();
	void go_NOP_SENT_IN_FWD();
	void go_NOP_SENT_IN_USER();
	void go_NOP_SENT_IN_EH();
	void go_NOP_SENT_IN_CSR();
	void go_FWD_DATA_SENT();
	void go_USER_DATA_SENT();
	void go_ERROR_DATA_SENT();
	void go_CSR_DATA_SENT();
	void go_LDTSTOP_DISCONNECT();
 
#ifdef RETRY_MODE_ENABLED
	void go_RETRY_NOP_SENT();
	void go_SEND_DATA_CRC();
	void go_RETRY_NOP_SENT_IN_DATA();
	void go_SEND_CMD_CRC();
	void go_RETRY_SEND_CMD_CRC_DATA();
	void go_RETRY_SEND_CMD_CRC();
	void go_RETRY_DATA_SENT();
	void go_RETRY_SEND_DISCONNECT();
	void go_NOP_CRC_SENT_IN_FWD();
#endif
	//@}
 
#ifdef RETRY_MODE_ENABLED
	///Find the next state during retry mode(combinatory process)
	/**
		@description This is the equivalent of the ::find_next_state() , 
		except that it is for when we are in a retry sequence
	*/
	void find_next_retry_state();
	///Set what ::find_next_retry_state() has found
	void go_next_retry_state();
	///Find the one hot encoded value of what packet type is being sent
	void set_foundh_sent_type (VirtualChannel vc , bool data);
#endif
 
	///SystemC Macro
	SC_HAS_PROCESS(flow_control_l3);
 
	///Macro CTOR SystemC - flow_control_l3 constructor
	flow_control_l3(sc_module_name name);
};
 
#endif