Subversion Repositories ht_tunnel

//flow_control_l2.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 ***** */
 
#ifndef FLOW_CONTROL_L2_H
#define FLOW_CONTROL_L2_H
 
#include "../core_synth/synth_datatypes.h"	
#include "../core_synth/constants.h"
 
//Forward declaration
class flow_control_l3;
class nop_framer_l3;
class multiplexer_l3;
class rx_farend_cnt_l3;
class user_fifo_l3;
class fairness_l3;
 
#ifdef RETRY_MODE_ENABLED
class history_buffer_l3;
class fc_packet_crc_l3;
#endif
 
/// Top module of the flow control
/**
	The flow control is the module that frames the packets to be sent out.
	In the HyperTransport tunnel, there are multiple sources of outgoing
	packets.  The flow control decides which packet must be sent.
 
	It keeps track of the buffers available in the next HT node.  It is
	also responsible for sending nop flow control packets when the databuffer
	or reordering requests it.  It will also send nops when there si nothing else
	to send.
 
	The module is also called the forward module, because it is responsible for
	sending packets that arrived from the other side of the tunnel but that
	wasn't for this node.
 
	In retry mode, the flow control keeps a history buffer of all the packets
	sent until they are acked, so they can be replayed if there is a transmission
	error.  It also add the CRC to every packet.
 
	Dwords are sent to the link, when the link is not busy.
 
	When the user interface requests that a packet that has data associated be sent,
	there is an two input buffers for every VC, one for packets with data and one for
	packets without data.  The command packet is sent directly to the flow control,
	so the input buffers for the user are actually located in the flow control so
	that it can decide from which VC it is best to send.  The data payload of the
	packet with data is kept in the user interface, so the flow control must request
	that data when sending a packet with data associated.
*/
class flow_control_l2 : public sc_module
{
	public:
	//***********************************
	// Ports definition
	//***********************************
 
	/// The Clock
	sc_in<bool> clk;
	/// Reset signal
	sc_in<bool> resetx;
	///LDTSTOP# signal
	sc_in<bool> ldtstopx;
 
    // USER_FIFO
	///The packet the user interface wants to send
    sc_in <sc_bv<64> >			ui_packet_fc;
	///If it there is a packet available to be sent
	sc_in <bool>				ui_available_fc;
	///The VC's that can accept packets currently
	sc_out <sc_bv<3> >			fc_user_fifo_ge2_ui;
 
	///The VC in which the flow control wants to read data from the UI data buffer
	sc_out <VirtualChannel>		fc_data_vc_ui;
	///The data from the UI buffers
	sc_in <sc_bv<32> >			ui_data_fc; 
	///To consume the data from the UI buffers
	sc_out <bool>				fc_consume_data_ui;
 
	// Forward -- FC
    ///If there is a packet to be sent from the reordering from the other side
    sc_in <bool> ro_available_fwd;
	///The packet to sent
    sc_in <syn_ControlPacketComplete > ro_packet_fwd;
	sc_in<VirtualChannel> ro_packet_vc_fwd;
	///To acknoledge that the packet has been consumed
    sc_out <bool> fwd_ack_ro;
 
   	//LINK
	///The dword to send to the other link
    sc_out <sc_bv<32> > fc_dword_lk;
	///The LCTL control signal to send along with the data
    sc_out <bool> fc_lctl_lk;
	///The HCTL control signal to send along with the data
    sc_out <bool> fc_hctl_lk;
	///The link consumes the data we are sending
    sc_in  <bool> lk_consume_fc;
#ifdef RETRY_MODE_ENABLED
	///Force the link to disconnect
	/**Disconnect will occur after the current dword is done sending*/
    sc_out <bool> fc_disconnect_lk;
	///This signal is active when the RX side of the link is connected
	sc_in  <bool> lk_rx_connected;
	///If the link wants to initiate a retry disconnect
	sc_in  <bool> lk_initiate_retry_disconnect;
	///If we are in the mode retry
	sc_in <bool> csr_retry;
	//Command decoder
	/**Turns on when a disconnect sequence is initiated
	All buffer counts are zeroed and we must replay all packets
	that have not been acked*/
	sc_in <bool>	cd_initiate_retry_disconnect;
#endif
 
	//DATA BUFFER
	///The address where to read the data
    sc_out <sc_uint<BUFFERS_ADDRESS_WIDTH> > fwd_address_db;
	///The VC in which to read the data
    sc_out <VirtualChannel>  fwd_vctype_db;
	///To read (consume) the data at the address specified
    sc_out <bool> fwd_read_db;
	///To erase the data packet
    sc_out <bool> fwd_erase_db;
	///The data received from the data buffer
    sc_in <sc_bv<32> > db_data_fwd;
 
 
    ///Buffer count information from RO and DB for sending nop's
	///The buffers the ro can notify as being free to the HT node we are connected to
	//Bits 1..0 : PC, Bits 3..2 : RC. Bits 5..4 : NPC
    sc_in <sc_bv<6> > ro_buffer_cnt_fc;
	///The buffers the ro can notify as being free to the HT node we are connected to
 	//Bits 1..0 : PC, Bits 3..2 : RC. Bits 5..4 : NPC
    sc_in <sc_bv<6> > db_buffer_cnt_fc;
 
    //Connexion Error handler FLOW control
	///Acknoledge that the dword has been read
	sc_out <bool> fc_ack_eh;
	///The dword to send (command packet or data payload)
	sc_in <sc_bv<32> > eh_cmd_data_fc;
	///If there is a dword to send
	sc_in <bool> eh_available_fc;
 
	//Connexion CSR -- FLOW control
	///Acknoledge that the dword has been read
	sc_out <bool> fc_ack_csr;	
	///If there is a dword to send
	sc_in <bool> csr_available_fc;
	///The dword to send (command packet or data payload)
	sc_in <sc_bv<32> > csr_dword_fc;
 
	///If we are to turn the transmitter off
	///Now ignored since reset is necessary to reactivate link.  transmitter off is taken care
	//of in the link only
	//sc_in <bool> csr_transmitteroff;
 
#ifdef RETRY_MODE_ENABLED
	///This bit forces a single stomp to be sent
	sc_in<bool>			csr_force_single_stomp_fc;
	///This bit forces a single CRC error to be sent
	sc_in<bool>			csr_force_single_error_fc;
	///Once a CRC error is sent, we clear the signal to send the error
	sc_out<bool>		fc_clear_single_error_csr;
	///Once a stomp is sent, we clear the signal to send the stomp
	sc_out<bool>		fc_clear_single_stomp_csr;
#endif
 
 
	//Connexion pour les NOP request
	///Databuffer requests that a nop be sent.
	sc_in <bool> db_nop_req_fc;
	///Reordering requests that a nop be sent.
	sc_in <bool> ro_nop_req_fc;
	///A nop was just sent
	sc_out <bool> fc_nop_sent;
 
	// NOP info packet
	///The buffer information received in a nop
	sc_in<sc_bv<12> > cd_nopinfo_fc;
	///If a nop was just received
    sc_in<bool> cd_nop_received_fc;
 
    ///Let the reordering know which buffers are free in the next node
	sc_out <sc_bv<6> > fwd_next_node_buffer_status_ro;
 
#ifdef RETRY_MODE_ENABLED
	///The packet that is acked in the nop (for retry mode)
	/**
		When we receive this ack value, we can erase the packet associated with
		that number (and all the previous ones) from our buffers.
	*/
	sc_in<sc_uint<8> > cd_nop_ack_value_fc;
 
	///CD maitains a count of valid packet received, that count is then sent in nops
	sc_in<sc_uint<8> > cd_rx_next_pkt_to_ack_fc;
 
	//////////////////////////////////////////
	//	Memory interface - synchronous
	/////////////////////////////////////////
	sc_out<bool> history_memory_write;///<Write to history memory
	sc_out<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_write_address;///<Address where to write in history memory
	sc_out<sc_bv<32> > history_memory_write_data;///<Data to write to history memory
	sc_out<sc_uint<LOG2_HISTORY_MEMORY_SIZE> > history_memory_read_address;///<Address where to read in history memory
	sc_in<sc_bv<32> > history_memory_output;///<Data read in history memory
 
 
	///To clear the farent count (like for when we initiate a retry sequence)
	sc_signal <bool>	clear_farend_count;
 
	//Connection to History buffers
	///The packet from the history buffer
	sc_signal <sc_bv<32> >	history_packet;
	///Signal from history buffers to tell that the playback is done
	sc_signal <bool >		history_playback_done;
	///Activate to make the history play back it's history
	sc_signal <bool >		begin_history_playback;
	///Activate to interrupt the history playback
	sc_signal <bool >		stop_history_playback;
	///When the history is ready to begin a playback sequence
	sc_signal <bool >		history_playback_ready;
	///To consume the dword from the history
	sc_signal <bool >		consume_history;
 
	///Signal from the history buffer to say how much room is available in the buffers
	sc_signal <bool > room_available_in_history;
 
	///To tell the history buffers to add to it's history the buffer being outputed to the link
	sc_signal <bool >		add_to_history;
	///Prepare a new entry in the history buffers
	sc_signal <bool >		new_history_entry;
	///The size of the entry to prepare
	sc_signal <sc_uint<5> > new_history_entry_size_m1;
 
 
	//Connection to CRC unit
	///To calculate the CRC from the current output
	sc_signal<bool>			calculate_crc;
	///Reset the value of the CRC
	sc_signal<bool>			clear_crc;
	///To calculate the CRC from the current output in and store in the alternate nop CRC register
	sc_signal<bool>			calculate_nop_crc;
	///Reset the value of the alternate nop CRC register
	sc_signal<bool>			clear_nop_crc;
	///The CRC register value
	sc_signal<sc_uint<32> >	crc_output;
	///The nop CRC register value
	sc_signal<sc_uint<32> >	nop_crc_output;
 
 
#endif
 
 
	///Controls the output mux which selects what is sent to the TX link
    sc_signal <sc_uint<4> > fc_ctr_mux;
 
 
 
	//------------------------------------------
	// Instanciation
	//------------------------------------------
	flow_control_l3* the_flow_control; ///>("the_flow_control");
    nop_framer_l3* the_nop_framer; ///>("the_nop_framer");
    multiplexer_l3* the_multiplexer; ///>("the_multiplexer");
	rx_farend_cnt_l3* the_rx_farend_cnt; ///>("the_rx_farend_cnt");
	user_fifo_l3* the_user_fifo; ///>("the_user_fifo");
	fairness_l3* the_fairness; ///>("the_fairness");
#ifdef RETRY_MODE_ENABLED
	history_buffer_l3* the_history_buffer;///>("the_history_buffer");
	fc_packet_crc_l3* the_fc_packet_crc;///>("the_fc_packet_crc");
#endif
 
    //***********************************
	// Intern Signals
	//***********************************
 
	    //FIFO --FC
	///packet coming from the user fifo
	sc_signal <sc_bv<64> > fifo_user_packet;
	///if there is packet available from the user fifo
	sc_signal<bool> fifo_user_available;
	///consume the data from the user fifo
    sc_signal <bool> consume_user_fifo;			//acknowledge
	///flow control (l3) is currently reading output, do not change it!
    sc_signal <bool> hold_user_fifo;
 
	/** @name Fifo registered modules
		These signals are not necessary, but they are registered in fifo
		module to accelerate the combinatorial path of the next module.
	*/
	//@{
	///Virtual channel of the ::fifo_user_packet
 	sc_signal<VirtualChannel> fifo_user_packet_vc;
	///If ::fifo_user_packet is a double word packet (as opposed to a quad word, word = 16 bits)
	sc_signal<bool> fifo_user_packet_dword;
	///If ::fifo_user_packet has any data associated
	sc_signal<bool> fifo_user_packet_data_asociated;
#ifdef RETRY_MODE_ENABLED
    ///
	sc_signal<PacketCommand > fifo_user_packet_command;
#endif
    ///Size of ::fifo_user_packet data in dwords minus 1
	sc_signal<sc_uint<4> > fifo_user_packet_data_count_m1;
    ///If ::fifo_user_packet has the chain bit on (also checks if it's a posted packet)
	sc_signal<bool> fifo_user_packet_isChain;
    //@}
 
    ///Dword coming from the nop generator    
	sc_signal <sc_bv<32> > ht_nop_pkt;
 
	//Fairness Algorithm
 
	///If the local side has priority
	sc_signal<bool> local_priority;
 
	///If a local packet is issued (can be sent or reserved to send when buffers available)
	sc_signal<bool> local_packet_issued;
 
 
 
	//NOP 
	///A nop is the next packet that must be sent after the current on has been sent
	sc_signal <bool> nop_next_to_send;
	///Disconnect nops must be generated
    sc_signal <bool> generate_disconnect_nop;
	///If the RO and DB have buffers to notify as being free to the next node
	sc_signal <bool> has_nop_buffers_to_send;
 
	///To select the CRC as output to the link
	sc_signal <bool> select_crc_output;
	///To select the nop CRC as output to the link
	sc_signal <bool> select_nop_crc_output;
 
    /// indicate the packet type that is sent. 
	//one hot encoding, meaning of bits :
	//0 - response data
	//1 - response command
	//2 - non-posted data
	//3 - non-posted command
	//4 - posted data
	//5 - posted command
	sc_signal <sc_bv<6> > current_sent_type;
 
	///The output of the registered MUX (selection of data source before per-packet CRC)
	sc_signal <sc_bv<32> > mux_registered_output;
 
	///SystemC macro
	SC_HAS_PROCESS(flow_control_l2);
 
	///constructor, instanciates sub-modules and links them
	flow_control_l2(sc_module_name name);
 
#ifdef RETRY_MODE_ENABLED
	///Takes care of sending the clear_single error and clear single stomp to the CSR
	void send_clear_single_error_and_stomp();
#endif
 
#ifdef SYSTEMC_SIM
	///class destructor in simulation, to free the instanciated sub-modules
	virtual ~flow_control_l2();
#endif
};
 
 
#endif