Subversion Repositories ht_tunnel

//link_fram_rx_l3_tb.cpp
/* ***** 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 ***** */
 
#include "link_frame_rx_l3_tb.h"
#include "../../core/require.h"
#include "link_rx_transmitter.h"
 
#include <sstream>
#include <string>
 
using namespace std;
 
link_frame_rx_l3_tb::link_frame_rx_l3_tb(sc_module_name name): sc_module(name){
	SC_THREAD(stimulate_inputs);
	sensitive_pos	<<	clk;
	SC_THREAD(validate_outputs);
	sensitive_pos	<<	clk;
 
	///Create and link transmitter submodule
	transmitter = new link_rx_transmitter("link_rx_transmitter");
	transmitter->clk(clk);
	transmitter->phy_ctl_lk(phy_ctl_lk);
	for(int n = 0; n < CAD_IN_WIDTH; n++){
		transmitter->phy_cad_lk[n](phy_cad_lk[n]);
	}
	transmitter->phy_available_lk(phy_available_lk);
	transmitter->lk_deser_stall_phy(lk_deser_stall_phy);
	transmitter->lk_deser_stall_cycles_phy(lk_deser_stall_cycles_phy);
}
 
 
link_frame_rx_l3_tb::~link_frame_rx_l3_tb(){ delete transmitter;}
 
void link_frame_rx_l3_tb::init(){
 
	/**
		Not much to understand here, just init misc variables
		to an initial state to start new.  You'll notice that
		reset is asserted and pwrok is de-asserted, meaning
		that this is a cold reset and re-initializes the RX
		part of the link.
	*/
 
	phy_ctl_lk = sc_uint<CAD_IN_DEPTH>(0);
	for(int n = 0; n < CAD_IN_WIDTH; n++){
		phy_cad_lk[n] = sc_uint<CAD_IN_DEPTH>(0);
	}
	phy_available_lk = true;
 
	resetx = false;
	pwrok = false;
	ldtstopx = false;
 
	/**
	Link widths
 
	000 8 bits 
	100 2 bits 
	101 4 bits 
	111  Link physically not connected 
	@{
	*/
	csr_rx_link_width_lk = "000";
 
	csr_end_of_chain = false;
	csr_sync = false;
	csr_extended_ctl_timeout_lk = false;
 
#ifdef RETRY_MODE_ENABLED
	///If we are in retry mode
	csr_retry = false;
	///Command decoder commands a retry disconnect
	cd_initiate_retry_disconnect = false;
#endif
 
 
	expect_connected = 0;
	expect_disable_receivers_phy = 0;
 
	expect_link_width_update = 0;
	expected_link_width = "000";
 
	expect_link_failure = 0;
 
	check_dword_reception = true;
 
 
}
 
void link_frame_rx_l3_tb::stimulate_inputs(){
	/////////////////////////////////////////////
	// Test link failure
	/////////////////////////////////////////////
 
	phy_ctl_lk = sc_uint<CAD_IN_DEPTH>(0);
	for(int n = 0; n < CAD_IN_WIDTH; n++){
		phy_cad_lk[n] = sc_uint<CAD_IN_DEPTH>(0);
	}
 
	phy_available_lk = true;
	resetx = false;
	pwrok = false;
	expect_connected = -4;
 
	for(int n = 0; n < 5; n++)
		wait();
 
	resetx = true;
	pwrok = true;
	expect_link_failure = 5;
	expect_link_width_update = 0;
 
	for(int n = 0; n < 5; n++)
		wait();
 
	///////////////////////////////////////
	// Do a normal valid cold reset
	///////////////////////////////////////
 
	cout << "Entered stimulate_inputs" << endl;
	init();
	expect_link_failure = 0;
	cout << "Init done" << endl;
 
	cout << "Cold reset" << endl;
	//Keep the cold reset
	for(int n = 0; n < 2; n++){
		wait();
	}
 
	//Clock from other node starts running
	phy_available_lk = true;
 
	//Keep the cold reset
	for(int n = 0; n < 4; n++){
		wait();
	}
 
	//Power is stable
	pwrok = true;
	//Not in ldtstop sequence
	ldtstopx = true;
 
 
	transmitter->send_initial_value(4);
 
 
	/////////////////////////////////////////////
	// Test normal 8 bit behavious, offset 1/3
	/////////////////////////////////////////////
 
	//End cold reset
	expect_link_width_update = 4;
	expected_link_width = "000";
	resetx = true;
 
	cout << "Init sequence" << endl;
	transmitter->send_init_sequence(1,3);
	expect_connected = 16;
 
	cout << "Data transmission" << endl;
 
	LinkTransmission transmit;
	transmit.dword = "0xA417F05B";
	transmit.lctl = true;
	transmit.hctl = true;
 
	expected_transmission.push(transmit);
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	transmit.dword = "0x11112222";
	transmit.lctl = true;
	transmit.hctl = false;
 
	expected_transmission.push(transmit);
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	transmit.dword = "0xFFBB3388";
	transmit.lctl = false;
	transmit.hctl = true;
 
	expected_transmission.push(transmit);
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	transmit.dword = "0x00000000";
	transmit.lctl = false;
	transmit.hctl = false;
 
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	for(int n = 0; n < 5; n++){
		wait();
	}
 
	resetx = false;
	expect_connected = -4;
 
	for(int n = 0; n < 5; n++){
		wait();
	}
 
	/////////////////////////////////////////////
	// Test normal 8 bit behavious, offset 0/0
	/////////////////////////////////////////////
	resetx = true;
 
	transmitter->send_init_sequence(0,0);
	expect_connected = 16;
 
	cout << "Data transmission" << endl;
 
	transmit.dword = "0xABCDEF01";
	transmit.lctl = true;
	transmit.hctl = true;
 
	expected_transmission.push(transmit);
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	transmit.dword = "0x55336644";
	transmit.lctl = true;
	transmit.hctl = false;
 
	expected_transmission.push(transmit);
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
 
	for(int n = 0; n < 5; n++)
		wait();
 
 
	////////////////////////////////////////////////////////////////
	// Testing LDTSTOP
	////////////////////////////////////////////////////////////////
	cout << "Testing LDTSTOP" << endl;
 
	check_dword_reception = false;
 
	expect_connected = -4;
	expect_disable_receivers_phy = 6;
	ldtstopx = false;
	ldtstop_disconnect_rx = true;
 
	transmit.dword = "0x00000000";
	transmit.lctl = false;
	transmit.hctl = false;
	for(int n = 0; n < 4; n++)
		transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	ldtstopx = true;
	ldtstop_disconnect_rx = false;
 
	expect_disable_receivers_phy = -210;
	transmitter->send_initial_value(210);
	expect_connected = 210;
 
	transmitter->send_init_sequence(0,0);
 
	transmit.dword = "0xABCDEF01";
	transmit.lctl = true;
	transmit.hctl = true;
 
 
	transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
 
 
	for(int n = 0; n < 5; n++)
		wait();
 
	////////////////////////////////////////////////////////////////
	// Testing protocol error (invalid CTL transition)
	////////////////////////////////////////////////////////////////
	cout << "Testing protocol error" << endl;
 
 
	sc_bv<CAD_IN_DEPTH> phy_ctl_lk_buf;
	for(int n = 0; n < CAD_IN_DEPTH; n++){
		phy_ctl_lk_buf[n] = (bool)(n % 2);
	}
	phy_ctl_lk = phy_ctl_lk_buf;
 
	phy_available_lk = true;
	expect_ctl_transition_error = 5;
	wait();
 
	transmit.dword = "0x00000000";
	transmit.lctl = true;
	transmit.hctl = true;
	for(int n = 0; n < 5; n++)
		transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	expect_ctl_transition_error = 0;
 
	resetx = false;
	expect_connected = -4;
 
	for(int n = 0; n < 5; n++){
		wait();
	}
 
 
	////////////////////////////////////////////////////////////////
	// Testing protocol error (invalid CTL transition) because of reset
	////////////////////////////////////////////////////////////////
	cout << "Testing protocol error because of reset" << endl;
 
	resetx = true;
 
	transmitter->send_init_sequence(0,0);
	expect_connected = 16;
 
	phy_ctl_lk_buf[0] = true;
	for(int n = 1; n < CAD_IN_DEPTH; n++){
		phy_ctl_lk_buf[n] = false;
	}
	phy_ctl_lk = phy_ctl_lk_buf;
 
	phy_available_lk = true;
	wait();
 
	expect_connected = -10;
 
	//Like reset signal
	transmit.dword = "0x00000000";
	transmit.lctl = false;
	transmit.hctl = false;
	for(int n = 0; n < 2; n++)
		transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	resetx = false;
	for(int n = 0; n < 5; n++){
		wait();
	}
 
	////////////////////////////////////////////////////////////////
	// Testing Retry mode disconnect from CD
	////////////////////////////////////////////////////////////////
 
	////////////////////////////////////////////////////////////////
	// Testing Retry mode with protocol error
	////////////////////////////////////////////////////////////////
	cout << "Testing protocol error with retry" << endl;
 
	resetx = true;
	csr_retry = true;
 
	transmitter->send_init_sequence(0,0);
	expect_connected = 16;
	for(int n = 0; n < CAD_IN_DEPTH; n++){
		phy_ctl_lk_buf[n] = (bool)(n % 2);
	}
	phy_ctl_lk = phy_ctl_lk_buf;
 
	phy_available_lk = true;
	expect_ctl_transition_error = 5;
	expect_lk_initiate_retry_disconnect = 5;
	wait();
 
	transmit.dword = "0x00000000";
	transmit.lctl = true;
	transmit.hctl = true;
	for(int n = 0; n < 3; n++)
		transmitter->send_dword_link(transmit.dword,transmit.lctl,transmit.hctl);
 
	expect_ctl_transition_error = 0;
 
	resetx = false;
	expect_connected = -4;
 
	for(int n = 0; n < 5; n++){
		wait();
	}
 
	////////////////////////////////////////////////////////////////
	// Done
	////////////////////////////////////////////////////////////////
	cout << "Link testbench done" << endl;
 
	while(true)
		wait();
 
}
 
 
 
void link_frame_rx_l3_tb::validate_outputs(){
	while(true){
		wait();
 
		//Test correctness of lk_rx_connected
		if(!expect_connected) verify(
			lk_rx_connected.read() == false,"Link should not be connected yet");
		else if(expect_connected > 0){
			verify(!(expect_connected == 1 && lk_rx_connected.read() == false),
				"Link failed to connect");
			if(!lk_rx_connected.read()) expect_connected--;
			else(expect_connected = 1);
		}
		else{
			verify(!(expect_connected == -1 && lk_rx_connected.read() == true),
				"Link failed to disconnect");
			if(lk_rx_connected.read()) expect_connected++;
			else expect_connected = 0;
		}
 
		//Test correctness of lk_disable_receivers_phy
		if(!expect_disable_receivers_phy) verify(
			lk_disable_receivers_phy.read() == false,"Link should not be disabled yet");
		else if(expect_disable_receivers_phy > 0){
			verify(!(expect_disable_receivers_phy == 1 && lk_disable_receivers_phy.read() == false),
				"Link failed to disable");
			if(!lk_disable_receivers_phy.read()) expect_disable_receivers_phy--;
			else(expect_disable_receivers_phy = 1);
		}
		else{
			verify(!(expect_disable_receivers_phy == -1 && lk_disable_receivers_phy.read() == true),
				"Link failed to re-enable");
			if(lk_disable_receivers_phy.read()) expect_disable_receivers_phy++;
			else expect_disable_receivers_phy = 0;
		}
 
		//Test correctness of lk_update_link_width_csr
		if(!lk_link_failure_csr.read()){
			if(!expect_link_width_update) verify(
				lk_update_link_width_csr.read() == false,"Unexpected update of link width");
			else {
				verify(!(expect_link_width_update == 1 && lk_update_link_width_csr.read() == false),
					"Link failed to update link width");
				if(!lk_update_link_width_csr.read()) expect_link_width_update--;
				else{
					ostringstream o;
					o << "Invalid updated link width value, Expected: " << expected_link_width << 
						" Received: " << lk_sampled_link_width_csr.read();
					verify(expected_link_width == lk_sampled_link_width_csr.read(),
						o.str().c_str());
					(expect_link_width_update = 0);
				}
			}
		}
 
		//Test correctness of lk_link_failure_csr
		if(!expect_link_failure) 
			verify(lk_link_failure_csr.read() == false,"Unexpected link failure");
		else{
			verify(!(expect_link_failure == 1 && lk_link_failure_csr.read() == false),
				"Link failed to fail : the link was supposed to fail and didn't");
			if(!lk_link_failure_csr.read()) expect_link_failure--;
			//else(expect_link_failure = 0);
		}
 
		//Test correctness of ctl_transition_error
		if(!expect_ctl_transition_error) 
			verify(ctl_transition_error.read() == false,"Unexpected ctl transition error");
		else{
			verify(!(expect_ctl_transition_error == 1 && ctl_transition_error.read() == false),
				"Link failed produce CTL error when it should have");
			if(!ctl_transition_error.read()) expect_ctl_transition_error--;
		}
 
		//Test correctness of lk_initiate_retry_disconnect
		if(!expect_lk_initiate_retry_disconnect) 
			verify(lk_initiate_retry_disconnect.read() == false,"Unexpected retry sequence initiated");
		else{
			verify(!(expect_lk_initiate_retry_disconnect == 1 && lk_initiate_retry_disconnect.read() == false),
				"Link failed to initiate retry sequence when it should have");
			if(!lk_initiate_retry_disconnect.read()) expect_lk_initiate_retry_disconnect--;
			else(expect_lk_initiate_retry_disconnect = 0);
		}
 
 
		//Test reception of data
		if(framed_data_available.read() && check_dword_reception){
			verify(!(expected_transmission.empty()),
				"Unexpected data reception");
			if(!expected_transmission.empty()){
				LinkTransmission t = expected_transmission.front();
 
				cout << "Data in front : L=" << t.lctl << " H=" <<
					t.hctl << " D=" << t.dword.to_string(SC_HEX) << endl;
				cout << "Data received : L=" << framed_lctl.read() << " H=" <<
					framed_hctl.read() << " D=" << framed_cad.read().to_string(SC_HEX) << endl;
 
				expected_transmission.pop();
 
				verify((t.dword == framed_cad.read() &&
						t.lctl == framed_lctl.read() &&
						t.hctl == framed_hctl.read()),
					"Invalid data received");
			}
		}
	}
}