// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Implements the interface to Bca & flow control.

// 

//

/**

 @file

*/

#include <e32uid.h>

#include <nifmbuf.h>

#include <es_ini.h>

#include <e32svr.h>

#include <u32hal.h>

#include "BcaController.h"

//In order not to flow off SPUD everytime we set the default to 1

const TUint KDefaultBufferSize=1;

#ifdef __EABI__

// Patch data is used and KMaxTxIPPacketSize and KMaxRxIPPacketSize can be modified to a different value in RawIpNif.iby file

extern const TInt KMaxSendQueueLen = KDefaultBufferSize;

extern const TInt KMaxTxIPPacketSize = KMaxIPPacket + KIPTagHeaderLength;

extern const TInt KMaxRxIPPacketSize = KMaxIPPacket + KIPTagHeaderLength;

#endif

CBcaController::CBcaController(MControllerObserver& aObserver,

	CBttLogger* aTheLogger)

/**

 * Constructor. 

 */

	: iObserver(aObserver),  

	  iTheLogger(aTheLogger),

	  iTxFlowControl(EFlowControlOff), 

	  iTxContextActive(ETrue), 

	  iSendState(EIdle),

	  iMaxSendQueueLen(KDefaultBufferSize),

	  iNumPacketsInSendQueue(0)

	{

	iSendQueue.Init();

	}

CBcaController::~CBcaController()

/**

 * Destructor.

 */

	{

	iSendQueue.Free();

	iNumPacketsInSendQueue = 0;

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

	delete iIPTagHeader;

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

	}

void CBcaController::BaseConstructL()

	{

	_LOG_L1C1(_L8("CBcaController::BaseConstructL"));

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

    iIPTagHeader = new (ELeave) CIPTagHeader(iTheLogger);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

#if defined (__EABI__)

    // Default value for queue length

    iMaxSendQueueLen = KMaxSendQueueLen;

	// Default value for Tx and Rx packet size

	iMaxTxPacketSize = KMaxTxIPPacketSize;

	iMaxRxPacketSize = KMaxRxIPPacketSize;

#else // WINS

	// Set default values in case patch is not present in epocrawip.ini

	iMaxSendQueueLen = KDefaultBufferSize;    

	iMaxTxPacketSize = KMaxIPPacket + KIPTagHeaderLength;

	iMaxRxPacketSize = KMaxIPPacket + KIPTagHeaderLength;

	// for the emulator process is patched via the epocrawip.ini file

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxSendQueueLen",&iMaxSendQueueLen);

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxTxIPPacketSize",&iMaxTxPacketSize);

	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxRxIPPacketSize",&iMaxRxPacketSize);

#endif

	}

void CBcaController::UpdateInternalFlowFlag(TFlowControl aValue)

/**

 *  Updates Internal Flow flag and resumes the data flow if

 *  necessary.

 *

 * @param aValue the new state of iInternalFlow

 */

	{

	_LOG_L1C3(_L8("CBcaController::UpdateInternalFlowFlag[NewValue=%d, iSendState=%d]"),

		aValue, iSendState);

	if(iTxFlowControl == aValue)

		{

		// C32 Sent the same indication signal twice. Nif will ignore it.

		_LOG_L2C1(_L8("WARNING CBcaController: Received same indication twice"));

		return;

		}

	// Update the flag value.

	iTxFlowControl = aValue;

	if(iTxFlowControl == EFlowControlOff)

		{

		// If the indication received turned flow control off...

		if (IsTxPossible() && (iSendState == EIdle))

			{

			// ... if the NIF is in the EWaiting state

			// then the data flow can be resumed. 

			ResumeSending();

			}

		}		

	else

		{

		// if the Flow Control is on we can remove all queued write requests

		EmptySendQueue();

		}

	}

void CBcaController::UpdateContextStateFlag(TBool aValue)

/**

 *  Updates Context State flag and resumes the data flow if

 *  necessary.

 *

 * @param aValue the new state of iTxContextState

 */

	{

	_LOG_L1C3(_L8("CBcaController::UpdateContextStateFlag[NewValue=%d, OldValue=%d]"),

		aValue, iTxContextActive);

	if(iTxContextActive == aValue)

		{

		return;

		}

	// Update the flag value.

	iTxContextActive = aValue;

	if(iTxContextActive)

		{

		// If the PDP context is active and...

		if (IsTxPossible() && (iSendState == EIdle))

			{

			// ... if the NIF is in the EWaiting state

			// then the data flow can be resumed. 

			ResumeSending();

			}

		}

	else

		{

		// if the PDP context is suspended we can remove all queued write requests

		EmptySendQueue();

		}

	}

TInt CBcaController::Send(RMBufChain& aPdu)

/**

 *  This method is called by CRawIPNifMain in order to send a packet down

 * to the BCA. 

 *

 *	@param aPdu a data packet

 */

	{

	_LOG_L1C1(_L8(">>CBcaController::Send"));

	// Check if NIF is shutting down

	if (iSendState == EShuttingDown)

		{

		_LOG_L2C1(_L8("    ERROR: Nif is shutting down"));

		aPdu.Free();

		return KErrDisconnected;

		}

	// check that this packet isnt too big - If it is, we dont want to send it or

	// add it to our queue

	if ((aPdu.Length() - aPdu.First()->Length()) > BcaSendBufferLength())

		{

		_LOG_L2C1(_L8("Packet is too large - discarding"));

		_LOG_L1C1(_L8("<<CSender::Send -> Error"));

		aPdu.Free();

		return KErrArgument;

		}

	if (iSendState == ESending)

		// If this happens, it means that TCP/IP has sent us an IP packet

		// while we're still sending the previous one. 

		{

		// check that the queue isnt full NB. this check should not be needed as when the 

		// queue becomes full the IP layer shouldnt send any more packets until it is told to

		if (!IsSendQueueFull())

			{

			_LOG_L1C1(_L8("    Sender busy, appending packet to queue"));

			//We know that flow control is off and context isnt suspended so can add to queue

			AppendToSendQueue(aPdu);

			return IsSendQueueFull() ? KStopSending : KContinueSending;

			}

		_LOG_L1C1(_L8("    Queue is full, upper layer is still sending packets, potential memory problems."));

		AppendToSendQueue(aPdu);

		return KStopSending;

		}

	// If we have got here then a write isnt currently happening

	// We dont need to check flow control is off and context isnt suspended as the BCA always

	// has room for one packet, so send the packet

	if(!IsSendQueueEmpty())

		{

		//make sure that we don't change the order of packets!

		//first send what has already been lined up

		RMBufChain tmpPdu;

		_LOG_L1C1(_L8("    Packet removed from queue to send"));

		RemoveFromSendQueue(tmpPdu);

		AppendToSendQueue(aPdu);

		// Update module state

		_LOG_L2C1(_L8("     set State to ESending"));

		iSendState = ESending;

		BcaSend(tmpPdu);

		}

	else

		{

		// Update module state

		_LOG_L2C1(_L8("     set State to ESending"));

		iSendState = ESending;

		BcaSend(aPdu);

		}

	_LOG_L2C1(_L8("<<CBcaController::Send - return StopSending/ContinueSending"));

	return IsSendQueueFull() ? KStopSending : KContinueSending;

	}

void CBcaController::SendComplete()	

/**

 *  This method is called after a packet was sent to the board. 

 *  If allowed by flow contol flags the NIF can signal the TCP/IP

 *  protocol indicating that is available to send more packets.

 */

	{

	_LOG_L1C1(_L8("CBcaController::SendComplete"));

	_LOG_L2C1(_L8("     set State to EIdle"));

	iSendState = EIdle;

	if (IsTxPossible())

		ResumeSending();

	}

TBool CBcaController::IsTxPossible()

/**

 *  This method returns ETrue if both TX flags are set to ETrue

 *

 * @return The Flow control state

 */

	{

	_LOG_L1C3(_L8("CBcaController::IsTxPossible (contextActive %d, flowcontrol %d)"), 

		iTxContextActive, iTxFlowControl);

	if(iTxContextActive && (iTxFlowControl == EFlowControlOff))

		return ETrue;

	else

		return EFalse;

	}

void CBcaController::Process(TDesC8& aPdu)

/**

 *  This method will pass on the received data to CBttNifMain. 

 *

 * @param aPdu a data packet

 */

	{

	_LOG_L1C1(_L8(">>CBcaController::Process"));

	TInt ret;

	// Create a packet object.

	RMBufPacket packet;

	TRAP(ret, packet.CreateL(aPdu));

	if (ret != KErrNone)

		{

		// Couldn't create package. Packet will be ignored...

		_LOG_L1C2(_L8("<<CBcaController::Process couldn't create MBuf [ret=%d]"), ret);

		return;

		}

	else

		// Package created...

		{

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

		TUint16 protocolCode = iIPTagHeader->RemoveHeader(packet);

#else

		TUint16 protocolCode = 0;

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

		packet.Pack();

		// Process the packet

		GetObserver().Process(packet, protocolCode);

		}

	_LOG_L1C1(_L8("<<CBcaController::Process"));

	}

void CBcaController::ResumeSending()

/**

 *  Used to indicate to the TCP/IP protocol layer that the NIF is ready to 

 *	process more packets.

 */

	{

	_LOG_L1C1(_L8("CBcaIoController::ResumeSending"));

	// If there are still some packets in the queue to be sent, then carry

	// on sending them.

	// NB. we only want to send more packets from the queue if we are currently EIdle

	if (iSendState == EIdle) 

		{

		if(!IsSendQueueEmpty())

			{

			RMBufChain tmpPdu;

			_LOG_L1C1(_L8("    Packet removed from queue to send"));

			RemoveFromSendQueue(tmpPdu);

			// Update module state

			_LOG_L2C1(_L8("     set State to ESending"));

			iSendState = ESending;

			BcaSend(tmpPdu);

			}

		if(iFullQueueFlag && IsSendQueueEmpty())

			{

			iObserver.ResumeSending();

			}

		}

	// if iSendState = ESending - do nothing

	}

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

void CBcaController::SetType(TUint16 aType)

	{

/**

 *  Used to specify the type of the IP header.

 */

 	_LOG_L1C1(_L8("CBcaController::SetType"));

 	iIPTagHeader->SetType(aType);	

	}

void CBcaController::AddHeader(TDes8& aDes)

/**

 *  Used to add the IP header to the packet before sending to the BCA.

 */

	{

	_LOG_L1C1(_L8("CBcaController::AddHeader"));

	iIPTagHeader->AddHeader(aDes);

	}

TUint16 CBcaController::RemoveHeader(RMBufChain& aPdu)

/**

 *  Used to remove the IP header from the received the packet before sending to the 

 *  TCP/IP layer.  

 * @return The IP header that has been removed from the packet

 */

	{

	_LOG_L1C1(_L8("CBcaController::RemoveHeader"));

	return (iIPTagHeader->RemoveHeader(aPdu));

	}	

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

TBool CBcaController::IsSendQueueEmpty()

/**

 *  Indicator of whether the BufferQueue is empty

 * @return TBool.  ETrue if bufferQueue is emtpy, EFalse if queue is not empty

 */

	{

	return iSendQueue.IsEmpty();

	}

TBool CBcaController::IsSendQueueFull()

/**

 *  Indicator of whether the BufferQueue is full

 * @return TBool.  ETrue if bufferQueue is full, EFalse if queue is not full

 */

	{    

	iFullQueueFlag = iNumPacketsInSendQueue >= iMaxSendQueueLen;

	return iFullQueueFlag;

	}	

void CBcaController::AppendToSendQueue(RMBufChain& aPdu)

/**

 * Appends the packet aPdu to the queue. 

 * Increments the packet count. Doesn't do error checking.

 * @param aChain buffer chain to be added

 */

	{

	iSendQueue.Append(aPdu);

	iNumPacketsInSendQueue++;

	}

TBool CBcaController::RemoveFromSendQueue(RMBufChain& aPdu)

/**

 * Removes the packet aPdu from the queue. 

 * Decrements the packet count.

 * @param aChain buffer chain to be added

 * @return False if chain is empty

 */

	{

	TBool ret = iSendQueue.Remove(aPdu);

	if(ret)

		{

		iNumPacketsInSendQueue--;

		}

	return ret;

	}

void CBcaController::EmptySendQueue()

/**

 * Removes all the packets from the send queue. Initializes the

 * send queue and sets the packet count to 0.

 */

	{

	iSendQueue.Free();

	iSendQueue.Init();

	iNumPacketsInSendQueue = 0;

	}