Subversion Repositories ht_tunnel

//link_rx_transmitter.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):
 *   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 LINK_RX_TRANSMITTER_H
#define LINK_RX_TRANSMITTER_H
 
#include "../../../rtl/systemc/core_synth/synth_datatypes.h"
 
///Allows to transmit data to the link in order to test it
/**
	@class link_rx_transmitter
	@author Ami Castonguay
	@description
	This is a module that takes care of transmitting data to the
	link in order to test it.  It takes care of sending an initial
	sequence and afterwards transmitting valid data.  It does not
	take care of CRC's.
 
	The transmitter can run at various bit-widths and also at
	different offsets.  What is meant by offset is that when data
	is received by the HT tunnel, it is deserialized to 32 bits from
	its original bit-width.  Because of this deserialization, the 
	final data might not be alligned naturally (the received 32-bit
	might contain the end of a dword and the beggining of another
	dword).  The transmitter takes care of simulating this.
 
 
	Natural allignment (offset of 0) is this for a 4 bit link:
	output0:  28 ... 9  5 1
	output1:  29 ... 10 6 2
	output2:  30 ... 11 7 3
	output3:  31 ... 12 8 4
 
	Offset of 2 is this for a 4 bit link:
	output0:  20 ... 9  5 1 + 28 24
	output1:  21 ... 10 6 2 + 29 25
	output2:  22 ... 11 7 3 + 30 26 
	output3:  23 ... 12 8 4 + 31 27
 
	The (+) marks a change in data dword, even if it's received in the same
	phy_cad_lk.
*/
class link_rx_transmitter : public sc_module{
 
public:
 
	sc_in<bool > clk;
 
	///CTL value sent to the HT tunnel
	sc_out<sc_bv<CAD_IN_DEPTH> >	phy_ctl_lk;
	///CAD value sent to the tunnel
	/** Every element of the array represent one input of the tunnel
		that was deserialized to a factor of CAD_IN_DEPTH*/
	sc_out<sc_bv<CAD_IN_DEPTH> >	phy_cad_lk[CAD_IN_WIDTH];
	///If CAD and CTL values are available to be consumed
	/** True when a dword is sent through the transmitter, false
		otherwise*/
	sc_out<bool>					phy_available_lk;
 
	///The bit-width of the link
	int bit_width;
	///The offset : how the data is offset from its natural allignment
	int transmission_offset;
	///The last data sent, so that it can be used when sending the data with offset
	sc_bv<32>	last_sent_dword;
	///The last lctl sent, so that it can be used when sending the data with offset
	bool		last_sent_lctl;
	///The last hctl sent, so that it can be used when sending the data with offset
	bool		last_sent_hctl;
 
#ifndef INTERNAL_SHIFTER_ALIGNMENT
	///High speed deserializer should stall shifting bits for lk_deser_stall_cycles_phy cycles
	/** Cannot be asserted with a lk_deser_stall_cycles_phy value of 0*/
	sc_in<bool > lk_deser_stall_phy;
	///Number of bit times to stall deserializing incoming data when lk_deser_stall_phy is asserted
	sc_in<sc_uint<LOG2_CAD_IN_DEPTH> > lk_deser_stall_cycles_phy;
 
	void realign();
 
	SC_HAS_PROCESS(link_rx_transmitter);
#endif
 
 
	///Constructor
	link_rx_transmitter(sc_module_name name);
 
	///Sends the correct CAD and CTL values to initialize the link
	/**
		@param offset1 Offset at the beggining of the init sequence
		@param offset2 Offset at the end of the init sequence.  It does not
			have to be the same as offset1.  offset2 will be the final offset
			that will be kept after the init sequence is done
	*/
	void send_init_sequence(int offset1, int offset2);
	///Sends a dword on the link
	/**
		@param dword The dword to send
		@param lctl The CTL value sent with the dword for first half of transmission
		@param hctl The CTL value sent with the dword for last half of transmission
		@param ctl_error If a CTL transition error should be introduced.  A
			transition at another moment than the half of the transmission will
			be made (which is illegal in HT)
	*/
	void send_dword_link(const sc_bv<32> & dword, 
				 bool lctl, bool hctl, bool ctl_error = false);
	///Send reset signaling
	void send_initial_value(int nb_cyles);
};
 
#endif