// 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:

// This file implements a loopback driver for use with 3GNIF test harness.

// 

//

/**

 @file

*/

#include <c32comm.h>

#include <c32comm_internal.h>

#include "Loopback.h"

#include "LoopbackConfig.h"

#include "LoopbackTimer.h"

#include "LoopbackQueue.h"

CHWPort::CHWPort(TUint aUnit) : iRole(ECommRoleDTE), iPortName(aUnit)

	{

	TName name;

	name.Format(_L("%d"),aUnit);

	SetName(&name);

	}

static void CloseObject(TAny* anObject)

/**

 * This method simply closes an object from the cleanup stack.  The object must contain

 * a Close method.

 *

 * @param	anObject - a TAny pointer to the object to close. 

 */

	{

	((CObject*)anObject)->Close();

	}

CHWPort* CHWPort::NewPacketLoopbackL(TUint aUnit, TUint aDelay, TUint aPacketLength, TUint aQueueLength)

/**

 * This method is used by the factory object to create the new CHWPort instances.

 * After newing the CHWPort object, the buffer is created, roles and signals are defaulted,

 * and names are initialized.

 *

 * @param	aUnit - the port number to create.

 * @param	aDelay - the delay for sending on the port

 * @param	aPacketLength - the size in bytes of a packet

 * @param	aQueueLength - the maximum number of packets to queue

 *

 * @return	A pointer to the created object

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:NewL: Called for Unit %d"), aUnit);

	CHWPort *p = new(ELeave) CHWPort(aUnit);

	TCleanupItem closePort(CloseObject,p);

	CleanupStack::PushL(closePort);

	p->ConstructPacketLoopbackL(aDelay, aPacketLength, aQueueLength);

	CleanupStack::Pop(p);

	return p;

	}

CHWPort* CHWPort::NewSerialLoopbackL(TUint aUnit, TUint aDelay, TUint aBufferSize)

/**

 * This method is used by the factory object to create the new CHWPort instances.

 * After newing the CHWPort object, the buffer is created, roles and signals are defaulted,

 * and names are initialized.

 *

 * @param	aUnit - the port number to create.

 * @param	aDelay - the delay for sending on the port

 * @param	aBuffersize - the size of the buffer to allocate

 *

 * @return	A pointer to the created object

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:NewL: Called for Unit %d"), aUnit);

	CHWPort *p = new(ELeave) CHWPort(aUnit);

	TCleanupItem closePort(CloseObject,p);

	CleanupStack::PushL(closePort);

	p->ConstructSerialLoopbackL(aDelay, aBufferSize);

	CleanupStack::Pop(p);

	return p;

	}

void CHWPort::ConstructSerialLoopbackL(TUint aDelay, TUint aBufferSize)

	{

	iWriteDelayTimer = CLoopbackTimer::NewL(aDelay, this);

	iFlowControlChange = CFlowControlChange::NewL(iPortName, this);

	iPortType = ESerialLoopbackPortType;

	TCommConfigV01 *config = &iConfig();

	iReadWriteQueue = CSerialBufferQueue::NewL(aBufferSize, config);

	}

void CHWPort::ConstructPacketLoopbackL(TUint aDelay, TUint aPacketLength, TUint aQueueLength)

	{

	iWriteDelayTimer = CLoopbackTimer::NewL(aDelay, this);

	iFlowControlChange = CFlowControlChange::NewL(iPortName, this);

	iReadWriteQueue = CPacketBufferQueue::NewL(aPacketLength, aQueueLength);

	}

TUint CHWPort::PortName() const

	{

	return iPortName;

	}

void CHWPort::SetLoopbackPort(CHWPort* aHWPort)

/**

 * This method sets up the loopback port member of the CHWPort.  It is used after

 * both ports have been created (NewL).  This allows each port to "know" to whom he is

 * connected.

 *

 * @param	aHWPort - the port which THIS port should be connected to.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:SetLoopbackPort:  Unit %d..."), iPortName);

	// Now set up the loopback

	iLoopbackPort = aHWPort;

	}

TBool CHWPort::GetFlowControl() const

/**

 * @return ETrue if flow control is on, EFalse if it is not

 */

	{

	return iFlowControlChange->FlowControlIsOn();

	}

void CHWPort::StartFlowControl()

/**

 * Performs any necessary actions to set flow control on

 */

	{

	iWriteDelayTimer->Cancel();

	}

void CHWPort::StopFlowControl()

/**

 * Performs any necessary actions to stop flow control

 */

	{

	if (!iLoopbackPort)

		{

		return;

		}

	if (iReadWriteQueue->IsWriteBufferEmpty())

		{

		return;

		}

	TInt nextWriteLen = iReadWriteQueue->PeekNextWriteBuffer().Length();

	if (!iLoopbackPort->iReadWriteQueue->IsReadBufferFull(nextWriteLen)

		&& !iWriteDelayTimer->IsActive())

		{

		iWriteDelayTimer->Start();

		}

	}

TInt CHWPort::GetReadRequestStatus()

/**

 * @return The status that Read() calls are to complete with

 */

	{

	TInt readRequestStatus = KErrNone;

	TInt ret = RProperty::Get(KUidPSCsyReadResultCategory, iPortName, readRequestStatus);

	if (ret == KErrNone)

		return readRequestStatus;

	// if we can't find this property, we make everything work

	return KErrNone;

	}

TInt CHWPort::GetWriteRequestStatus()

/**

 * @return The status that Write() calls are to complete with

 */

	{

	TInt writeRequestStatus = KErrNone;

	TInt ret = RProperty::Get(KUidPSCsyWriteResultCategory, iPortName, writeRequestStatus);

	if (ret == KErrNone)

		return writeRequestStatus;

	// if we can't find this property, we make everything work

	return KErrNone;

	}

void CHWPort::StartRead(const TAny* aClientBuffer, TInt aLength)

/**

 * This method queues a read operation to the driver.  If the read length is zero (which is a

 * special case used during initialization) the read completes immediately.

 * If the read buffer is insufficient in size, the read completes with error KErrOverflow.

 *

 * @param	aClientBuffer	- a TAny * to the buffer into which data is placed.

 * @param	aLength			- the length of the buffer supplied

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:StartRead:  Unit %d..."), iPortName);

	// Because a length of zero is a special case (for initialization), we will complete this immediately

	if(aLength == 0)

		{

		ReadCompleted(KErrNone);

		return;

		}

	else if(aLength < 0)

		{

		// if the read is through the function ReadOneOrMore, the length will be negative

		// in this CSY, the behavior is always ReadOneOrMore

		aLength = -aLength;

		iReadOneOrMore = ETrue;

		}

	else // aLength > 0

		{

		iReadOneOrMore = EFalse;

		}

	// Save the client read buffer

	iClientReadBuffer = aClientBuffer;

	iClientReadBufferLength = aLength;

	iReadPending = ETrue;

	// if there is already an entry in the read buffer, we can complete the read now

	TryToCompleteRead();

	}

void CHWPort::TryToCompleteRead()

/**

 * This method attempts to complete reads - it is either called as they are initially issued (and is

 * completed if there is data already in the read buffer), or is is called later, when data is supplied 

 * to the read buffer (and is completed if there is a read waiting)

 * Data is moved from the buffer associated with this port to a buffer that was supplied by the client 

 * when the read was issued.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:TryToCompleteRead: Unit %d ..."), iPortName);

	// If there is not read pending or no loopback port, we can't complete a read

	if (!iReadPending)

		return;

	if (!iLoopbackPort)

		return;

	// Determine if there an entry available to be read

	if (iReadWriteQueue->IsReadBufferEmpty())

		return;

	TInt res = KErrNone;

	TBool completeIfBufferNotFull;

	TPtrC8 nextReadBuffer = iReadWriteQueue->PeekNextReadBuffer(completeIfBufferNotFull);

	if ( iClientReadBufferLength > nextReadBuffer.Length() )

		{

		if (iPortType == ESerialLoopbackPortType) 

			{

		 	if (iReadOneOrMore == EFalse) 

				{

		 		if (!completeIfBufferNotFull)

		 			{

					return;

		 			}

				}

			}

		}

	TInt readRequestStatus = GetReadRequestStatus();

	if ( (iClientReadBufferLength < nextReadBuffer.Length()) && (iPortType == EPacketLoopbackPortType) )

		{

		// The client buffer is not large enough

		res = KErrOverflow;

		}

	else if (readRequestStatus != KErrNone)

		{

		// We are configured to complete with an error

		res = readRequestStatus;

		iReadWriteQueue->DiscardNextReadBuffer();

		}

	else

		{

		// Write the data to the client's supplied buffer

		res = IPCWrite(iClientReadBuffer, nextReadBuffer, 0);

		if(res == KErrNone)

			{

			// It is normally the writing buffer's responsibility to start the timer, but in the case where the 

			// reading port's buffer is full, now that the read buffer is no longer full, we have to signal to the 

			// writing port to start sending again

			if (!iLoopbackPort->iReadWriteQueue->IsWriteBufferEmpty())

				{

				TInt nextWriteLen = iLoopbackPort->iReadWriteQueue->PeekNextWriteBuffer().Length();

				if (iReadWriteQueue->IsReadBufferFull(nextWriteLen)

					&& !iLoopbackPort->iWriteDelayTimer->IsActive() )

					{

					iLoopbackPort->iWriteDelayTimer->Start();

					}

				}

			// Read has been completed successfully, so dequeue

			iReadWriteQueue->DiscardNextReadBuffer();

			}

		}

	// complete the read

	iReadPending = EFalse;

	LOGTEXT3(_L8("PKTLOOPBACK:TryToCompleteRead: Unit %d completing read with error %d"), iPortName, res);

	ReadCompleted(res);

	}

void CHWPort::ReadCancel()

/**

 * Cancel a pending read and complete it with KErrCancel. The handling of the CActive class

 * will by default complete any outstanding read with KErrCancel, but it is cleaner to handle

 * that processing here.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:ReadCancel:  Unit %d..."), iPortName);

	iReadPending = EFalse;

	ReadCompleted(KErrCancel);

	}

TInt CHWPort::WriteBuf(const TAny* aClientBuffer, TInt aLength)

/**

 * This method queues the client buffer to the loopback port.

 * A delay in the port is simulated, so the read corresponding to this buffer will not complete

 * until after this delay. The buffers are queued up and sent one per delay period.

 *

 * @param	aClientBuffer	- a TAny * to the buffer which contains the data to write

 * @param	aLength			- the length of the buffer.

 *

 * @return	KErrNone if everything is okay, KErrOverflow if the write queue is full and no more entries can be written until some have been sent, 

 * KErrNotReady	if the loopback port has not yet been opened or there is no loopback port configured for this port, or KErrArgument	if the supplied buffer is too large

 */

	{

	TInt res = KErrNone;

	LOGTEXT2(_L8("PKTLOOPBACK:WriteBuf:  Unit %d..."), iPortName);

	TInt writeRequestStatus = GetWriteRequestStatus();

	if (writeRequestStatus != KErrNone)

		return writeRequestStatus;

	// Fill the receiving buffer

	if (aLength != 0)

		{

		if (iReadWriteQueue->IsWriteBufferFull(aLength))

			{

			return KErrOverflow;

			}

		if (aLength > iReadWriteQueue->BufferSize())

			{

			return KErrArgument;

			}

		TPtr8 currentPacket = iReadWriteQueue->AppendToWriteBuffer(aLength);

		res = IPCRead(aClientBuffer, currentPacket);

		if(res != KErrNone)

			return res;

		}

	// Queue up the request and start the timer to simulate the delay in sending the data across the port

	if (!iWriteDelayTimer->IsActive())

		{

		iWriteDelayTimer->Start();

		}

	return KErrNone;

	}

void CHWPort::TimerCallBack()

/**

 * This method is called after the simulated delay for sending data across the port

 */

	{

	if (!iLoopbackPort)

		{

		return;

		}

	if (iReadWriteQueue->IsWriteBufferEmpty())

		{

		return;

		}

	TPtrC8 writeBuffer = iReadWriteQueue->PeekNextWriteBuffer();

	if (iLoopbackPort->iReadWriteQueue->IsReadBufferFull(writeBuffer.Length()))

		{

		return;

		}

	// Move the buffer from the write queue to the read queue

	iLoopbackPort->iReadWriteQueue->AppendToReadBuffer(writeBuffer);

	iReadWriteQueue->DiscardNextWriteBuffer();

	// If the loopback port has a read outstanding it can complete now

	iLoopbackPort->TryToCompleteRead();

	// If there is another write outstanding we have to simulate a delay for that entry

	if (!iReadWriteQueue->IsWriteBufferEmpty() && !iWriteDelayTimer->IsActive())

		{

		iWriteDelayTimer->Start();

		}

	}

TInt CHWPort::QueryReceiveBuffer(TInt& aLength) const

/**

 * This method returns the length of the buffer associated with this instance of the

 * port.

 *

 * @param	aLength			- a reference to return the length of the buffer.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:QueryReceiveBuffer:  Unit %d..."), iPortName);

	TBool dummy;

	const TPtrC8& iReadBuf = iReadWriteQueue->PeekNextReadBuffer(dummy);

	aLength = iReadBuf.Length();

	return KErrNone;

	}

void CHWPort::ResetBuffers(TUint)

/**

 * This method resets the buffer used by this loopback port 

 *

 * @note Note that most ResetBuffers methods derived from CPort allow a parameter for flags.

 * This ResetBuffers method does not.

 *

 * @param	Not Used

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:ResetBuffers:  Unit %d..."), iPortName);

	iReadWriteQueue->Clear();

	}

void CHWPort::StartWrite(const TAny* aClientBuffer,TInt aLength)

/**

 * This method queues a write operation to the driver.

 *

 * @param	aClientBuffer	- a TAny * to the buffer into which data should be read.

 * @param	aLength			- the length of the data to be written.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:StartWrite:  Unit %d..."), iPortName);

	TInt res = WriteBuf(aClientBuffer, aLength);

	LOGTEXT3(_L8("PKTLOOPBACK:StartWrite:  Completing Write for Unit %d with error %d"), iPortName, res);

	WriteCompleted(res);

	}

void CHWPort::WriteCancel()

/**

 * This method cancels a pending write and issues a WriteCompleted with the result

 * KErrCancel.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:WriteCancel:  Unit %d..."), iPortName);

	WriteCompleted(KErrCancel);

	}

void CHWPort::Break(TInt /*aTime*/)

/**

 * This method is currently not implemented in the loopback driver as breaks are

 * not supported.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:Break is not supported:  Unit %d..."), iPortName);

	}

void CHWPort::BreakCancel()

/**

 * This method is currently not implemented in the loopback driver as breaks are

 * not supported.

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:BreakCancel is not supported:  Unit %d..."), iPortName);

	}

TInt CHWPort::GetConfig(TDes8& /*aDes*/) const

/**

 * This gets the current configuration from the loopback driver.

 * 

 * @return KErrNotSupported

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:GetConfig is not supported:  Unit %d..."), iPortName);

	return KErrNotSupported;

	}

TInt CHWPort::SetConfig(const TDesC8& aDes)

/**

 * This sets the current configuration for the loopback driver.  Note that

 * no error checking is done when setting the configuration.

 *

 * @return KErrNotSupported

 */

	{

	LOGTEXT2(_L8("PKTLOOPBACK:SetConfig is not supported:  Unit %d..."), iPortName);

	iConfig.Copy(aDes);

	return KErrNone;

	}

TInt CHWPort::GetCaps(TDes8& aDes)

/**

 * This gets the supported capabilities from the loopback driver.  The actual capabilities of

 * the driver will vary based on the role the port is playing (DCE or DTE).  The loopback driver

 * supports capabilities via TCommCapsV01 and TCommCapsV02.

 *

 * @param	aDes				- a TDes8 reference to copy the capabilities into.

 *

 * @return	KErrNone			- Everything is okay, KErrNotSupported it the length of the descriptor passed to this method indicates a

 *								  capabilities structure which we don't support.