Subversion Repositories ht_tunnel

//PhysicalLayer.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 "PhysicalLayer.h"
 
#include <iostream>
 
const int PhysicalLayer::PHYSICAL_LAYER_CRC_POLY = 0x04C11DB7;
 
PhysicalLayer::PhysicalLayer(sc_module_name name) : sc_module(name){
	SC_THREAD(receiveThread);
	sensitive_pos(clk);
 
	SC_THREAD(transmitThread);
	sensitive_pos(clk);
 
	inter = NULL;
	tx_connected = false;
	rx_connected = false;
	retryDisconnectCountTX = 0;
	retryDisconnectCountRX = 0;
	ldtstop_sequence = false;
	ldtstop_sequence_complete = false;
 
	//Get a vector of all zeros and ones;
	v0 = 0;
	v1 = ~v0;
}
 
void PhysicalLayer::ldtstopDisconnect(){
	ldtstop_sequence = true;
	ldtstop_sequence_complete = false;
	ltdstop_last_crc_window = false;
}
 
void PhysicalLayer::ldtstopConnect(){
	ldtstop_sequence = false;
	ldtstop_sequence_complete = false;
}
 
void PhysicalLayer::retryDisconnectAndReconnect(){
	retryDisconnectCountTX = 60;
	retryDisconnectCountRX = 40;
}
 
void PhysicalLayer::receiveThread(){
	phy_consume_lk = true;
	while(inter){
		//Do nothing while disconnected
		while(!resetx.read() || ltdstop_rx_received_disconnect || retryDisconnectCountRX){
			if(retryDisconnectCountRX) retryDisconnectCountRX--;
			rx_connected = false;
			wait();
			if(!ldtstop_sequence) ltdstop_rx_received_disconnect = false;
		}
		if(!rx_connected) rx_connect();
		receiveDwordOrCrc();
	}
	cout << "ERROR: No interface connected to the PhysicalLayer" << endl;
}
 
void PhysicalLayer::transmitThread(){
	phy_available_lk = true;
	while(inter){
		if(!resetx.read() || ldtstop_sequence && ldtstop_sequence_complete || retryDisconnectCountTX)
			holdResetSignaling();
		if(!tx_connected) tx_connect();
		sendNextDwordOrCrc();
	}
}
 
void PhysicalLayer::holdResetSignaling(){
	tx_connected = false; 
	phy_ctl_lk = v0;
	for(int n = 0; n < CAD_OUT_WIDTH;n++) phy_cad_lk[n] = v1;
	//while reset, LDTSTOP sequence of RETRY disconnect, keep sending reset signaling
	while(!resetx.read() || ldtstop_sequence && ldtstop_sequence_complete  || retryDisconnectCountTX){
		if(retryDisconnectCountTX){
			retryDisconnectCountTX--;
		}
		if(!resetx.read()) ldtstop_sequence = false;
		wait();
	}
}
 
 
void PhysicalLayer::tx_connect(){
	cout << "Starting TX Connect" << endl;
	//Connect sequence phase 1
	phy_ctl_lk = v1;
 
	for(int n = 0; n < CAD_OUT_WIDTH;n++) phy_cad_lk[n] = v1;
 
	//Wait for RX CTL to be asserted
	while(!(bool)(sc_bit)lk_ctl_phy.read()[0]) wait();
 
	//Wait a minimum time
	for(int n = 0; n < 4; n++) wait();
 
 
	//Connect sequence phase 2
	phy_ctl_lk = v0;
	for(int n = 0; n < CAD_OUT_WIDTH;n++) phy_cad_lk[n] = v0;
	for(int n = 0; n < 128; n++) wait();
 
 
 
	//Connect sequence phase 3
	for(int n = 0; n < CAD_OUT_WIDTH;n++) phy_cad_lk[n] = v1;
	wait();
	cout << "Done TX Connect" << endl;
 
	tx_firstCrcWindow = true;
	current_tx_crc = 0xFFFFFFFF;
	tx_crc_count = 0;
	tx_connected = true; 
}
 
void PhysicalLayer::calculateCrc(int &crc,int dword,bool lctl,bool hctl){
	//Break loop in 4 because data is bigger than 32 bits
	for(int n=0; n < 4;n++){
		int ctl_or = 0;
		if(((n == 0 || n == 1) && lctl) || (n == 2 || n == 3) && hctl){
			ctl_or = 0x100;
		}
 
		int data =( (dword >> (n * 8)) & 0xFF) | ctl_or;
 
		//Code taken from HT spec
		for(int i = 0; i < 9; i++){
			int tmp = crc >> 31;//store highest bit
			crc = (crc << 1) | ((data >> i) & 1);//shift message in
			crc = (tmp) ? crc ^ PHYSICAL_LAYER_CRC_POLY : crc;//substract poly if greater
		}
	}
}
 
void PhysicalLayer::sendNextDwordOrCrc(){
	//Get next dword to send through interface
	sc_bv<32> dword;
	bool lctl;
	bool hctl;
	if(!ldtstop_sequence)
		inter->dwordToSendRequested(dword,lctl,hctl);
	else{
		dword = 64; lctl = true; hctl = true;
	}
 
	//Calculate the CRC for it
	calculateCrc(current_tx_crc,dword.to_int(),lctl,hctl);
 
	//Send it
	sendDword(dword,lctl,hctl);
 
	//Now send crc if at the right position in the window
	tx_crc_count++;
	if(!tx_firstCrcWindow && tx_crc_count == 16){
		sc_bv<32> dword_to_sent = ~current_tx_crc;
		sendDword(dword_to_sent,true,true);
		if(ltdstop_last_crc_window) ldtstop_sequence_complete = true;
	}
 
	if(tx_crc_count == 128){
		if(ldtstop_sequence) ltdstop_last_crc_window = true;
		tx_firstCrcWindow = false;
		tx_crc_count = 0;
		last_tx_crc = current_tx_crc;
		current_tx_crc = 0xFFFFFFFF;
	}
}
 
void PhysicalLayer::sendDword(sc_bv<32> &dword,bool lctl,bool hctl){
	sc_bv<CAD_IN_DEPTH> v;
 
	//Send the ctl bits
	for(int n = 0; n < CAD_IN_DEPTH/2;n++) v[n] = lctl;
	for(int n = CAD_IN_DEPTH/2; n < CAD_IN_DEPTH;n++) v[n] = hctl;
	phy_ctl_lk = v;
 
	//Send the cad bits
	for(int y = 0; y < CAD_IN_WIDTH;y++){
		for(int x = 0; x < CAD_IN_DEPTH;x++){
			v[x] = dword[x * CAD_IN_WIDTH + y]; 
		}
		phy_cad_lk[y] = v;
	}
	//Send the dword
	wait();
}
 
void PhysicalLayer::rx_connect(){
	cout << "Begin RX connect" << endl;
 
	//Phase 1 - reset signaling
	while(lk_ctl_phy.read()[0] == false)wait();
 
	//Phase 2 - CTL activated
	while(lk_ctl_phy.read()[0] == true)wait();
 
	//Phase 3 - Wait for CAD to activate
	while(lk_cad_phy[0].read()[0] == false)wait();
 
	cout << "Done RX connect" << endl;
 
	//Wait for the next valid data
	wait();
	rx_crc_count = 0;
	current_rx_crc = 0xFFFFFFFF;
	rx_firstCrcWindow = true;
	rx_connected = true;
}
 
void PhysicalLayer::receiveDwordOrCrc(){
	sc_bv<32> dword;
	bool lctl;
	bool hctl;
 
	//Receive Dword
	receiveDword(dword,lctl,hctl);
	calculateCrc(current_rx_crc,dword.to_int(),lctl,hctl);
	rx_crc_count++;
 
	if(dword == 0x40 && lctl && hctl && ldtstop_sequence){
		ltdstop_rx_received_disconnect = true;
		return;
	}
 
	//cout << "Sending received dword: " << dword << endl;
	inter->receivedDwordEvent(dword,lctl,hctl);
 
	//Check CRC at the right moment in the windows
	if(!rx_firstCrcWindow && rx_crc_count == 16){
		receiveDword(dword,lctl,hctl);
		if(~last_rx_crc != dword.to_int()){
			//cout << "CRC received: " << dword.to_string(SC_HEX) << endl;
			//cout << "CRC expected: " << sc_uint<32>(last_rx_crc).to_string() << endl;
			inter->crcErrorDetected();
		}
	}
 
	//Reset window after 128 dwords
	if(rx_crc_count == 128){
		last_rx_crc = current_rx_crc;
		current_rx_crc = 0xFFFFFFFF;
		rx_crc_count = 0;
		rx_firstCrcWindow = false;
	}
}
 
void PhysicalLayer::receiveDword(sc_bv<32> &dword,bool &lctl,bool &hctl){
	sc_bv<CAD_OUT_DEPTH> v;
 
	//Receive the CTLS
	lctl = (sc_bit)lk_ctl_phy.read()[0];
	hctl = (sc_bit)lk_ctl_phy.read()[CAD_OUT_DEPTH/2];
 
	//Receive cad bits
	for(int y = 0; y < CAD_OUT_WIDTH;y++){
		v = lk_cad_phy[y].read();
		for(int x = 0; x < CAD_OUT_DEPTH;x++){
			dword[x * CAD_OUT_WIDTH + y] = v[x]; 
		}
	}
 
	//Allow to receive next dword
	wait();
}