Subversion Repositories ht_tunnel

//InterfaceLayer.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 "../core/PacketContainer.h"
#include "InterfaceLayer.h"
 
#include <iostream>
 
using namespace std;
 
 
InterfaceLayer::InterfaceLayer(sc_module_name name) : sc_module(name){
	SC_THREAD(rx_process);
	sensitive_pos(clk);
 
	SC_THREAD(tx_process);
	sensitive_pos(clk);
 
	receivePacket = NULL;
	tx_state = TX_IDLE;
	rx_state = RX_IDLE;
}
 
InterfaceLayer::~InterfaceLayer(){
	///Free all packet and data allocated memory
	for(deque<PacketAndData>::iterator i = packetQueue.begin();
		i != packetQueue.end(); i++)
	{
		delete (*i).packet;
		delete [] (*i).data;
	}
	//Might still be NULL, that's OK
	delete receivePacket;
}
 
void InterfaceLayer::tx_process(){
	while(true){
		if(!resetx.read()) tx_state = TX_IDLE;
		else{
		switch(tx_state){
		case TX_SEND_DATA:
		{
			sc_bv<64> bv;
			bv.range(63,32) = 0;
			bv.range(31,0) = packetQueue.front().data[tx_data_sent];
			usr_packet_ui = bv;
 
			//Send data until we reached the data count for that packet
			if(tx_data_sent++ == packetQueue.front().packet->getDataLengthm1()){
				delete packetQueue.front().packet;
				delete [] packetQueue.front().data;
				packetQueue.pop_front();
				tx_state = TX_IDLE;
			}
		}
			break;
		default:
			//If nothing to send, don't activate user available
			if(packetQueue.empty()) usr_available_ui = false;
			else{
				///Check the VC of the next packet to send, and if it has data
				VirtualChannel vc = packetQueue.front().packet->getVirtualChannel();
				bool hasData = packetQueue.front().packet->hasDataAssociated();
 
				///Check if there is enough buffers so that it can be sent
				bool canSend;
				if(vc == VC_POSTED){
					canSend = (sc_bit)ui_freevc0_usr.read()[5] && (sc_bit)ui_freevc1_usr.read()[5] &&
						(!hasData || (sc_bit)ui_freevc0_usr.read()[4] && (sc_bit)ui_freevc1_usr.read()[4]);					
				}
				else if(vc == VC_NON_POSTED){
					canSend = (sc_bit)ui_freevc0_usr.read()[3] && (sc_bit)ui_freevc1_usr.read()[3] &&
						(!hasData || (sc_bit)ui_freevc0_usr.read()[2] && (sc_bit)ui_freevc1_usr.read()[2]);					
				}
				else{
					canSend = (sc_bit)ui_freevc0_usr.read()[1] && (sc_bit)ui_freevc1_usr.read()[1] &&
						(!hasData || (sc_bit)ui_freevc0_usr.read()[0] && (sc_bit)ui_freevc1_usr.read()[0]);					
				}
 
				///If enough buffers
				if(canSend){
					///Make the next dword available
					usr_available_ui = true;
					///Output the packet
					usr_packet_ui = packetQueue.front().packet->getVector();
					///If it has data associated, go to the state to send it
					if(hasData){
						tx_state = TX_SEND_DATA;
						tx_data_sent = 0;
					}
					//otherwise delete the current packet entry
					else{
						delete packetQueue.front().packet;
						delete [] packetQueue.front().data;
						packetQueue.pop_front();
					}
				}
				else  usr_available_ui = false;
			}
		}
		}
		wait();
	}
}
 
void InterfaceLayer::rx_process(){
	//Always consume what is received
	usr_consume_ui = true;
	while(true){
		if(!resetx.read()) rx_state = RX_IDLE;
		else{
 
		switch(rx_state){
		case RX_RECEIVE_DATA:
			//store data
			receiveData[rx_received_data] = ui_packet_usr.read().range(31,0).to_int();
			//If receiving data is done, go back to an idle state
			if(rx_received_data++ == receivePacket->getDataLengthm1()){
				handler->receivedInterfacePacketEvent(receivePacket,receiveData,
					receiveDirecRoute,receiveSide,this);
				rx_state = RX_IDLE;
			}
			break;
		default:
			//If there is data available
			if(ui_available_usr.read()){
				//Create a packet from the quad word
				PacketContainer c = ControlPacket::createPacketFromQuadWord(ui_packet_usr);
				//Delete the previous received packet and replace with new
				delete receivePacket;
				receivePacket = c.giveControl();
				receiveSide = ui_side_usr.read();
				receiveDirecRoute = ui_directroute_usr.read();
 
				//If it has data, go to data receiving state
				if(receivePacket->hasDataAssociated()){
					rx_state = RX_RECEIVE_DATA;
					rx_received_data = 0;
				}
				//Otherwise, launch event that packet is received
				else{
					handler->receivedInterfacePacketEvent(receivePacket,NULL,
						receiveDirecRoute,receiveSide,this);
				}
			}
		}
		}
		wait();		
 
	}
}
 
void InterfaceLayer::sendPacket(ControlPacket * packet,int * data,bool side){
	//Add the packet to the queue
	PacketAndData pad;
	pad.packet = packet;
	pad.data = data;
	pad.side = side;
	packetQueue.push_back(pad);
}
 
void InterfaceLayer::flush(){
	//wait until the send queue is empty
	while(!packetQueue.empty()) wait();
}