// Copyright (c) 1999-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:

//

#include <kernel/kern_priv.h>

#ifdef SYMBIAN_OLD_EXPORT_LOCATION

#include <comms-infras/legacy_loopback_driver.h>

#else

//this header is not exported, needs to be a user include

#include "legacy_loopback_driver.h"

#endif

#include "device.h"

// Name for PDD, must match LDD name with a '.' and distinguishing name appended

_LIT(KLegacyLoopbackPddName,"legacy_loopback.pdd");

typedef TBuf8<KLoopbackMTU> TMTUBuffer;

class TQueue

	{

public:

	TMTUBuffer* HeadBuffer() {return &iQueue[iQueueHead];}

	TMTUBuffer* TailBuffer() {return &iQueue[iQueueTail];}

	TBool IsEmpty() const {return iLength == 0;}

	TBool IsFull() const {return iLength == KLoopbackQueueLen;}

	TInt MaxLength() const {return KLoopbackQueueLen;}

	TInt Length() const {return iLength;}

	void Pop()

		{

		__ASSERT_ALWAYS(iLength > 0, Kern::Fault("comms loopback", KErrOverflow));

		iQueueHead++;

		if(iQueueHead == KLoopbackQueueLen)

			{

			iQueueHead = 0;

			}

		iLength--;

		}

	void Push()

		{

		__ASSERT_ALWAYS(iLength < KLoopbackQueueLen, Kern::Fault("comms loopback", KErrOverflow));

		iQueueTail++;

		if(iQueueTail == KLoopbackQueueLen)

			{

			iQueueTail = 0;

			}

		iLength++;

		}

	TQueue() : iQueueHead(0), iQueueTail(0), iLength(0) {}

private:

	TMTUBuffer iQueue[KLoopbackQueueLen];

	TInt iQueueHead;

	TInt iQueueTail;

	TInt iLength;

	};

class DESockLoopbackDevice : public DESockLoopback

	{

public:

	DESockLoopbackDevice(DESockLoopbackPddFactory* aFactory);

	~DESockLoopbackDevice();

	TInt DoCreate();

	// Inherited from DESockLoopback. These called by the LDD.

	virtual TInt BufferSize() const;

	virtual TInt Speed() const;

	virtual TInt SetSpeed(TInt aSpeed);

	virtual TInt RequestDataSend();

	virtual void SendDataCancel();

	virtual TInt RequestDataReceipt();

	virtual void ReceiveDataCancel();

	virtual TDes8& SendBuffer();

	virtual TDesC8& ReceiveBuffer();

	virtual TBool ReceivedQueueLen();

	virtual void AdvanceReceiveQueue();

private:

	void SendDataCallback();

	void ReceiveDataCallback();

	static void DataRecvCallback(TAny* aSelf);

	void DoDataRecvCallback();

private:

	DESockLoopbackPddFactory* iFactory;

	TInt iSpeed;

	TQueue iSendQueue;

	TQueue iReceiveQueue;

	TBool iPendingRead;

	TDfc iRecvDataDfc;

	};

const TInt KESockLoopbackThreadPriority = 27;

_LIT(KESockLoopbackThread,"ESockLoopbackThread");

/**

  Standard export function for PDDs. This creates a DPhysicalDevice derived object,

  in this case, our DESockLoopbackPddFactory

*/

DECLARE_STANDARD_PDD()

	{

	return new DESockLoopbackPddFactory;

	}

DESockLoopbackPddFactory::DESockLoopbackPddFactory()

	{

	// Set version number for this device

	iVersion=RLegacyLoopbackDriver::VersionRequired();

	}

/**

  Second stage constructor for DPhysicalDevice derived objects.

  This must at least set a name for the driver object.

  @return KErrNone or standard error code.

*/

TInt DESockLoopbackPddFactory::Install()

	{

	// Allocate a kernel thread to run the DFC 

	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KESockLoopbackThreadPriority, KESockLoopbackThread);

	if (r == KErrNone)

		{ 

		r = SetName(&KLegacyLoopbackPddName);

		} 	

	return r;

	}

/**

  Returns the drivers capabilities. This is not used by the Symbian OS device driver framework

  but may be useful for the LDD to use.

  @param aDes Descriptor to write capabilities information into

*/

void DESockLoopbackPddFactory::GetCaps(TDes8& aDes) const

	{

	// Create a capabilities object

	DESockLoopback::TCaps caps;

	caps.iVersion = iVersion;

	// Zero the buffer

	TInt maxLen = aDes.MaxLength();

	aDes.FillZ(maxLen);

	// Copy cpabilities

	TInt size=sizeof(caps);

	if(size>maxLen)

		size=maxLen;

	aDes.Copy((TUint8*)&caps,size);

	}

/**

  Called by the kernel's device driver framework to create a Physical Channel.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aChannel Set to point to the created Physical Channel

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aVer The version number of the Logical Channel which will use this Physical Channel 

  @return KErrNone or standard error code.

*/

TInt DESockLoopbackPddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)

	{

	// Ignore the parameters we aren't interested in...

	(void)aUnit;

	(void)aInfo;

	(void)aVer;

	// Create a new physical channel

	DESockLoopbackDevice* device=new DESockLoopbackDevice(this);

	aChannel=device;

	if (!device)

		return KErrNoMemory;

	return device->DoCreate();

	}

/**

  Called by the kernel's device driver framework to check if this PDD is suitable for use with a Logical Channel.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aVer The version number of the Logical Channel which will use this Physical Channel 

  @return KErrNone or standard error code.

*/

TInt DESockLoopbackPddFactory::Validate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)

	{

	// Check version numbers

	if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(EMinimumLddMajorVersion,EMinimumLddMinorVersion,EMinimumLddBuild))))

		return KErrNotSupported;

	// We don't support units

    if (aUnit != -1)

        return KErrNotSupported;

	// Ignore extra info, (this could be used for validation purposes)

	// Note, aInof is a pointer to a descriptor in user memory, therefore safe methods should

	// be used for reading its contents. E.g. using Kern::KUDesGet()

	(void)aInfo;

	// OK

	return KErrNone;

	}

DESockLoopbackPddFactory::~DESockLoopbackPddFactory()

	{

	if (iDfcQ)

		iDfcQ->Destroy();

	}

DESockLoopbackDevice::DESockLoopbackDevice(DESockLoopbackPddFactory* aFactory)

	:	iFactory(aFactory),

		iSpeed(100000),  // 100000us (100ms) per byte

		iSendQueue(),

		iReceiveQueue(),

		iRecvDataDfc(DataRecvCallback, this, aFactory->iDfcQ, 1)

	{

	}

DESockLoopbackDevice::~DESockLoopbackDevice()

	{

	// Driver no longer using hardware resources

	NKern::LockedDec(iFactory->iHardwareInUse);

	}

TInt DESockLoopbackDevice::DoCreate()

	{

	// Claim the hardware resources by incrementing iHardwareInUse.

	// Must do this before any other failure can happen in this function so that

	// the destructor can safely decrement iHardwareInUse.

	//

	// This method of ensuring hardware is only in use by one driver at a time

	// wouldn't be needed if the driver claimed real hardware resources which

	// could only be used once. E.g. binding to an interrupt.

	if(NKern::LockedInc(iFactory->iHardwareInUse))

		return KErrInUse;

	// Other setup goes here

	return KErrNone;

	}

TInt DESockLoopbackDevice::BufferSize() const

	{

	return iSendQueue.MaxLength();

	}

TInt DESockLoopbackDevice::Speed() const

	{

	return iSpeed;

	}

TInt DESockLoopbackDevice::SetSpeed(TInt aSpeed)

	{

	if(aSpeed<=0)

		return KErrArgument;

	iSpeed = aSpeed;

	return KErrNone;

	}

TInt DESockLoopbackDevice::RequestDataSend()

	{

	// Push our send buffer in to the queue

	iSendQueue.Push();

	// Trigger reception

	NKern::Lock(); 

	SendDataCallback();

	NKern::Unlock(); 

	return KErrNone;

	}

void DESockLoopbackDevice::SendDataCancel()

	{

	}

void DESockLoopbackDevice::SendDataCallback()

	{

	// Tell self new data is coming

	iRecvDataDfc.Add();

	// Tell LDD we've done sending

	iLdd->SendDataComplete(KErrNone);

	}

TInt DESockLoopbackDevice::RequestDataReceipt()

	{

	iPendingRead = ETrue;

	if(!(iReceiveQueue.IsEmpty() && iSendQueue.IsEmpty()))

		{

		NKern::Lock(); 

		ReceiveDataCallback();

		NKern::Unlock(); 

		}

	return KErrNone;

	}

void DESockLoopbackDevice::ReceiveDataCancel()

	{

	}

void DESockLoopbackDevice::ReceiveDataCallback()

	{

	// Copy buffer from send queue (it's like our receive hardware) to receive queue

	if(!iReceiveQueue.IsFull() && !iSendQueue.IsEmpty())

		{

		// Copy the buffer from one queue to the other and patch up descriptor

		TDes8* srcDesc = iSendQueue.HeadBuffer();

		TDes8* destDesc = iReceiveQueue.TailBuffer();

		const TUint8* srcPtr = srcDesc->Ptr();

		const TUint8* destPtr = destDesc->Ptr();

		TInt length = srcDesc->Length();

		memcpy((void*)destPtr, (void*)srcPtr, length);

		destDesc->SetLength(length);

		// Bump the receive queue now that we have loaded it

		iReceiveQueue.Push();

		// Drop our incoming buffer

		iSendQueue.Pop();

		// If there is a pending read request then we can now satisfy it

		if(iPendingRead)

			{

			iPendingRead = FALSE;

			// Tell LDD we're done

			iLdd->ReceiveDataComplete(KErrNone);

			}

		}

	}

TDes8& DESockLoopbackDevice::SendBuffer()

	{

	return *iSendQueue.TailBuffer();

	}

TDesC8& DESockLoopbackDevice::ReceiveBuffer()

	{

	return *iReceiveQueue.HeadBuffer();

	}

void DESockLoopbackDevice::AdvanceReceiveQueue()

	{

	iReceiveQueue.Pop();

	}

TInt DESockLoopbackDevice::ReceivedQueueLen()

	{

	return iReceiveQueue.Length();

	}

void DESockLoopbackDevice::DataRecvCallback(TAny* aSelf)

	{

	((DESockLoopbackDevice*)aSelf)->ReceiveDataCallback();

	}