Subversion Repositories ht_tunnel

//link_frame_tx_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 <cstdlib>
 
#include "link_frame_tx_l3_tb.h"
#include "../../core/require.h"
 
using namespace std;
 
link_frame_tx_l3_tb::link_frame_tx_l3_tb(sc_module_name name): sc_module(name){
	SC_THREAD(stimulate_inputs);
	sensitive_pos	<<	clk;
 
	validator = new link_tx_validator("link_tx_validator");
 
	validator->clk(clk);
 
	validator->lk_ctl_phy(lk_ctl_phy);
	for(int n = 0; n < CAD_OUT_WIDTH; n++){
		validator->lk_cad_phy[n](lk_cad_phy[n]);
	}
 
	validator->tx_consume_data(tx_consume_data);
 
	validator->phy_consume_lk(phy_consume_lk);
	validator->cad_to_frame(cad_to_frame);
	validator->lctl_to_frame(lctl_to_frame);
	validator->hctl_to_frame(hctl_to_frame);
}
 
void link_frame_tx_l3_tb::init(){
	cout << "TB Init" << endl;
 
	csr_tx_link_width_lk = "000";
	validator->bit_width = 8;
	if(validator->bit_width > CAD_OUT_WIDTH) validator->bit_width = CAD_OUT_WIDTH;
 
	csr_end_of_chain = false;
 
	///Link commands a ltdstop disconnect
	ldtstop_disconnect_tx = false;
	rx_waiting_for_ctl_tx = false;
 
 
	resetx = false;
	pwrok = false;
	ldtstopx = false;
 
 
#ifdef RETRY_MODE_ENABLED
	///The flow control asks us to disconnect the link
	fc_disconnect_lk = false;
#endif
 
	validator->expect_tx_consume_data = 0;
	srand(389);
}
 
void link_frame_tx_l3_tb::stimulate_inputs(){
	cout << "TB Stimulate inputs" << endl;
	init();
 
	for(int n = 0; n < 5; n++) wait();
 
	//Enable power
	pwrok = true;
	ldtstopx = true;
 
	for(int n = 0; n < 5; n++) wait();
 
	//End reset
	resetx = true;
 
	cout << "Test connection 8 BIT" << endl;
	cout << "TB: Wait for connection" << endl;
 
	int max_count = 4300/CAD_OUT_DEPTH;
 
	//Give a first dword before being connected so that it's ready when
	//the link gets connected
	link_tx_validator::LinkTransmission_TX t;
	t.dword = "0x9812ABF4";
	t.lctl = true;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	//Wait until the validator says that we are in the normal RUN mode(init is done)
	while(validator->state != link_tx_validator::LinkTBState_RUN){
		max_count--;
		if(max_count == 0)
			cout << "*** ERROR: Link didn't initialize" << endl;
		wait();
	}
	cout << "TB: Connection established" << endl;
 
 
	t.dword = "0x94FF32D2";
	t.lctl = true;
	t.hctl = false;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	t.dword = "0x9DE3AC01";
	t.lctl = false;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	validator->expect_tx_consume_data = 50;
 
	//We are testing for an 8 bit link width, so if link is initialized
	//with full width, it should take 3 cycles to send 3 dwords.  If
	//the link is 4 bits, it will take 6 cycles, and if 2 it will take
	//12 cycles.  The formula is simple : 24/width.  If the link is
	//smaller than 8 bits, there will be an additional delay for the first
	//packet to be output, hence the added 8/width - 1 cycles.
	for(int n = 32 / validator->bit_width - 1; n > 0; n--){
		wait();
	}
 
	validator->expect_tx_consume_data = -20;
	resetx = false;
	validator->state = link_tx_validator::LinkTBState_INACTIVE;
 
	for(int n = 0; n < 5; n++) wait();
 
	csr_tx_link_width_lk = "101";
	validator->bit_width = 4;
	//End reset
	resetx = true;
 
	cout << "Test connection 4 BIT" << endl;
	cout << "TB: Wait for connection" << endl;
 
	max_count = 4300/CAD_OUT_DEPTH;
 
	t.dword = "0x9812ABF4";
	t.lctl = true;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	while(validator->state != link_tx_validator::LinkTBState_RUN){
		max_count--;
		if(max_count == 0)
			cout << "*** ERROR: Link didn't initialize" << endl;
		wait();
	}
	cout << "TB: Connection established" << endl;
 
 
	t.dword = "0x94FF32D2";
	t.lctl = true;
	t.hctl = false;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	t.dword = "0x9DE3AC01";
	t.lctl = false;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	validator->expect_tx_consume_data = 50;
 
	//Same as before
	for(int n = 32 / validator->bit_width - 1; n > 0; n--){
		wait();
	}
 
	validator->expect_tx_consume_data = -20;
	resetx = false;
	validator->state = link_tx_validator::LinkTBState_INACTIVE;
 
	for(int n = 0; n < 5; n++) wait();
 
	csr_tx_link_width_lk = "100";
	validator->bit_width = 2;
	//End reset
	resetx = true;
 
	cout << "Test connection 2 BIT" << endl;
	cout << "TB: Wait for connection" << endl;
 
	max_count = 4300/CAD_OUT_DEPTH;
 
	t.dword = "0x9812ABF4";
	t.lctl = true;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	while(validator->state != link_tx_validator::LinkTBState_RUN){
		max_count--;
		if(max_count == 0)
			cout << "*** ERROR: Link didn't initialize" << endl;
		wait();
	}
	cout << "TB: Connection established" << endl;
 
 
	t.dword = "0x94FF32D2";
	t.lctl = true;
	t.hctl = false;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	t.dword = "0x9DE3AC01";
	t.lctl = false;
	t.hctl = true;
	validator->expected_transmission.push(t);
	validator->to_transmit.push(t);
 
	validator->expect_tx_consume_data = 50;
 
	//Same as before
	for(int n = 32 / validator->bit_width - 1; n > 0; n--){
		wait();
	}
 
	validator->expect_tx_consume_data = -20;
	resetx = false;
	validator->state = link_tx_validator::LinkTBState_INACTIVE;
 
	while(true) wait();
 
}