// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// e32\e32test\demandpaging\d_pagingexample_2_pre.cpp
// Demand paging migration example device driver d_pagingexample_2_pre: a
// DLogicalChannelBase-dervied driver, pre-migration
// 
//

#include "d_pagingexample.h"
#include <kernel/kernel.h>
#include <kernel/kern_priv.h>

const TInt KBufferSize = KMaxTransferSize;

//
// Logical channel
//

class DExampleChannel : public DLogicalChannelBase
	{
public:
	typedef RPagingExample::TConfigData TConfigData;
	typedef RPagingExample::TValueStruct TValueStruct;
public:
	DExampleChannel();
	~DExampleChannel();
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);
	TInt DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2);
	TInt DoCancel(TUint aMask);
private:
 	TDfcQue* DfcQ();
	void Shutdown();
	void GetConfig(TConfigData&);
	void SetConfig(const TConfigData&);
	TInt StartNotify(TRequestStatus* aStatus);
	TInt StartAsyncGetValue(TInt* aValue, TRequestStatus* aStatus);
	TInt StartAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus);
	TInt StartRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);
	TInt StartReadDes(TDes8* aDesOut, TRequestStatus* aStatus);
	TInt StartWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);
	TInt StartWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus);
	void ReceiveToReadBuffer();
	void SendFromWriteBuffer();
	static void CancelDfcFunc(TAny* aPtr);
	static void AsyncGetValueCompleteDfcFunc(TAny* aPtr);
	static void AsyncGetValue2CompleteDfcFunc(TAny* aPtr);
	static void ReceiveCompleteDfcFunc(TAny* aPtr);
	static void SendCompleteDfcFunc(TAny* aPtr);
	void CompleteNotify();
	void CompleteAsyncGetValue();
	void CompleteAsyncGetValue2();
	void CompleteRead();
	void CompleteWrite();
	void Cancel();
private:
	NFastMutex iLock;
	TConfigData iConfig;
	DThread* iClient;
	TDfc iCancelDfc;
	
	// Notify
	TRequestStatus* iNotifyStatus;
	
	// Async get value
	TRequestStatus* iAsyncGetValueStatus;
	TInt* iAsyncGetValueDest;
	NTimer iAsyncGetValueTimer;
	TDfc iAsyncGetValueDfc;

	// Async get value 2
	TRequestStatus* iAsyncGetValue2Status;
	TInt* iAsyncGetValue2Dest1;
	TInt* iAsyncGetValue2Dest2;
	NTimer iAsyncGetValue2Timer;
	TDfc iAsyncGetValue2Dfc;
	
	// Read
	TRequestStatus* iReadStatus;
	NTimer iReadTimer;
	TAny* iReadDest;
	TInt iReadLength;
	TDes8* iReadDes;
	TDfc iCompleteReadDfc;
	
	// Write
	TRequestStatus* iWriteStatus;
	NTimer iWriteTimer;
	TAny* iWriteSrc;
	TInt iWriteLength;
	const TDesC8* iWriteDes;
	TDfc iCompleteWriteDfc;
	TUint8 iBuffer[KBufferSize];
	};

DExampleChannel::DExampleChannel() :
	iCancelDfc(CancelDfcFunc, this, DfcQ(), 0),
	iAsyncGetValueTimer(NULL, this),
	iAsyncGetValueDfc(AsyncGetValueCompleteDfcFunc, this, DfcQ(), 0),
	iAsyncGetValue2Timer(NULL, this),
	iAsyncGetValue2Dfc(AsyncGetValue2CompleteDfcFunc, this, DfcQ(), 0),
	iReadTimer(NULL, this),
	iCompleteReadDfc(ReceiveCompleteDfcFunc, this, DfcQ(), 0),
	iWriteTimer(NULL, this),
	iCompleteWriteDfc(SendCompleteDfcFunc, this, DfcQ(), 0)
	{
	iClient = &Kern::CurrentThread();
	iClient->Open();
	}

DExampleChannel::~DExampleChannel()
	{
	Kern::SafeClose((DObject*&)iClient, NULL);
	}

TDfcQue* DExampleChannel::DfcQ()
	{
	return Kern::DfcQue0();
	}

TInt DExampleChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
	return KErrNone;
	}

TInt DExampleChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)
	{
	TInt r = KErrNone;	
	if (&Kern::CurrentThread() != iClient)
		r = KErrAccessDenied;  // we only support one client
	else if (aReqNo==KMaxTInt)
		{
		// DoCancel
		r = DoCancel((TInt)a1);
		}
    else if (aReqNo<0)
		{
		// DoRequest
		TRequestStatus* pS=(TRequestStatus*)a1;
		TAny* array[2] = { NULL, NULL };
		kumemget32(array, a2, 2 * sizeof(TAny*));
		r = DoRequest(~aReqNo, pS, array[0], array[1]);
		if(r != KErrNone)
			Kern::RequestComplete(pS, r);
		r = KErrNone;
		}
    else
		{
		// DoControl
		r = DoControl(aReqNo, a1, a2);
		}
	return r;
	}

TInt DExampleChannel::DoControl(TInt aFunction,TAny* a1,TAny* /*a2*/)
	{
	TInt r = KErrNone;
	TConfigData configBuffer;
	switch (aFunction)
		{
		case RPagingExample::EGetConfig:
			GetConfig(configBuffer);
			umemput32(a1, (TAny*)&configBuffer, sizeof(TConfigData));
			break;

		case RPagingExample::ESetConfig:
			umemget32(&configBuffer, a1, sizeof(TConfigData));
			SetConfig(configBuffer);
			break;

		default:
			r = KErrNotSupported;
		}
	return r;
	}

TInt DExampleChannel::DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2)
	{
	TInt r = KErrNotSupported;
	switch (aFunction)
		{
		case RPagingExample::ERequestNotify:
			r = StartNotify(aStatus);
			break;
			
		case RPagingExample::ERequestAsyncGetValue:
			r = StartAsyncGetValue((TInt*)a1, aStatus);
			break;
			
		case RPagingExample::ERequestAsyncGetValue2:
			r = StartAsyncGetValue2((TInt*)a1, (TInt*)a2, aStatus);
			break;
			
		case RPagingExample::ERequestRead:
			r = StartRead(a1, (TInt)a2, aStatus);
			break;
			
		case RPagingExample::ERequestReadDes:
			r = StartReadDes((TDes8*)a1, aStatus);
			break;

		case RPagingExample::ERequestWrite:
			r = StartWrite(a1, (TInt)a2, aStatus);
			break;
			
		case RPagingExample::ERequestWriteDes:
			r = StartWriteDes((TDes8*)a1, aStatus);
			break;
		}
	return r;
	}

TInt DExampleChannel::DoCancel(TUint /*aMask*/)
	{
	iCancelDfc.Enque();
	return KErrNone;
	}

void DExampleChannel::CancelDfcFunc(TAny* aPtr)
	{
	DExampleChannel* self = (DExampleChannel*)aPtr;
	self->Cancel();
	}

void DExampleChannel::Cancel()
	{
	if (iAsyncGetValueStatus)
		{
		iAsyncGetValueTimer.Cancel();
		iAsyncGetValueDfc.Cancel();
		Kern::RequestComplete(iClient, iAsyncGetValueStatus, KErrCancel);
		}

	if (iAsyncGetValue2Status)
		{
		iAsyncGetValue2Timer.Cancel();
		iAsyncGetValue2Dfc.Cancel();
		Kern::RequestComplete(iClient, iAsyncGetValue2Status, KErrCancel);
		}

	if (iReadStatus)
		{
		iReadTimer.Cancel();
		iCompleteReadDfc.Cancel();
		Kern::RequestComplete(iClient, iReadStatus, KErrCancel);
		}

	if (iWriteStatus)
		{
		iWriteTimer.Cancel();
		iCompleteWriteDfc.Cancel();
		Kern::RequestComplete(iClient, iWriteStatus, KErrCancel);
		}
	}

void DExampleChannel::Shutdown()
	{
	}

void DExampleChannel::GetConfig(TConfigData& aConfigOut)
	{
	NKern::FMWait(&iLock);
	aConfigOut = iConfig;
	NKern::FMSignal(&iLock);
	}

void DExampleChannel::SetConfig(const TConfigData& aNewConfig)
	{
	NKern::FMWait(&iLock);
	iConfig = aNewConfig;
	NKern::FMSignal(&iLock);
	}

TInt DExampleChannel::StartNotify(TRequestStatus* aStatus)
	{
	iNotifyStatus = aStatus;	
	CompleteNotify(); // example implementation completes the request immediately
	return KErrNone;
	}

void DExampleChannel::CompleteNotify()
	{
	Kern::RequestComplete(iClient, iNotifyStatus, KErrNone);
	}

TInt DExampleChannel::StartAsyncGetValue(TInt* aValue, TRequestStatus* aStatus)
	{
	iAsyncGetValueDest = aValue;
	iAsyncGetValueStatus = aStatus;

	// queue a timer to simulate an asynchronous operation
	iAsyncGetValueTimer.OneShot(KAsyncDelay, iAsyncGetValueDfc);
	return KErrNone;
	}

void DExampleChannel::AsyncGetValueCompleteDfcFunc(TAny* aPtr)
	{
	DExampleChannel* self = (DExampleChannel*)aPtr;
	self->CompleteAsyncGetValue();
	}

void DExampleChannel::CompleteAsyncGetValue()
	{
	TValueStruct value;
	value.iValue1 = 1;
	value.iValue2 = _L8("shrt");
	TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValueDest, (TAny*)&value, sizeof(TValueStruct), iClient);
	Kern::RequestComplete(iClient, iAsyncGetValueStatus, r);
	}

TInt DExampleChannel::StartAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus)
	{
	iAsyncGetValue2Dest1 = aValue1;
	iAsyncGetValue2Dest2 = aValue2;
	iAsyncGetValue2Status = aStatus;

	// queue a timer to simulate an asynchronous operation
	iAsyncGetValue2Timer.OneShot(KAsyncDelay, iAsyncGetValue2Dfc);
	return KErrNone;
	}

void DExampleChannel::AsyncGetValue2CompleteDfcFunc(TAny* aPtr)
	{
	DExampleChannel* self = (DExampleChannel*)aPtr;
	self->CompleteAsyncGetValue2();
	}

void DExampleChannel::CompleteAsyncGetValue2()
	{
	TInt value1 = 1;
	TInt value2 = 2;
	TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest1, (TAny*)&value1, sizeof(TInt), iClient);
	if (r == KErrNone)
		r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest2, (TAny*)&value2, sizeof(TInt), iClient);
	Kern::RequestComplete(iClient, iAsyncGetValue2Status, r);
	}

TInt DExampleChannel::StartRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)
	{
	if (!NKern::CompareAndSwap(*(TAny**)&iReadStatus, NULL, aStatus))
		return KErrInUse;
	if (aLength < 1 || aLength > KBufferSize)
		{
		iReadStatus = NULL;
		return KErrArgument;
		}
	iReadDest = aBuffer;
	iReadLength = aLength;
	ReceiveToReadBuffer();
	return KErrNone;
	}

TInt DExampleChannel::StartReadDes(TDes8* aDesOut, TRequestStatus* aStatus)
	{
	if (!NKern::CompareAndSwap(*(TAny**)&iReadStatus, NULL, aStatus))
		return KErrInUse;
	TInt r = Kern::ThreadGetDesMaxLength(iClient, aDesOut);
	if (r < 0)
		{
		iReadStatus = NULL;
		return r;
		}
	TInt length = r;
	if (length < 1 || length > KBufferSize)
		{
		iReadStatus = NULL;
		return KErrArgument;
		}
	iReadDes = aDesOut;
	iReadLength = length;
	ReceiveToReadBuffer();
	return KErrNone;
	}

TInt DExampleChannel::StartWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)
	{
	if (!NKern::CompareAndSwap(*(TAny**)&iWriteStatus, NULL, aStatus))
		return KErrInUse;
	if (aLength < 1 || aLength > KBufferSize)
		{
		iWriteStatus = NULL;
		return KErrArgument;
		}
	iWriteSrc = aBuffer;
	iWriteLength = aLength;
	SendFromWriteBuffer();
	return KErrNone;
	}

TInt DExampleChannel::StartWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus)
	{
	if (!NKern::CompareAndSwap(*(TAny**)&iWriteStatus, NULL, aStatus))
		return KErrInUse;
	TInt r = Kern::ThreadGetDesLength(iClient, aDesIn);
	if (r < 0)
		return r;
	TInt length = r;
	if (length < 1 || length > KBufferSize)
		{
		iWriteStatus = NULL;
		return KErrArgument;
		}
	iWriteLength = length;
	iWriteDes = aDesIn;
	SendFromWriteBuffer();
	return KErrNone;
	}

void DExampleChannel::ReceiveToReadBuffer()
	{
	// just queue a timer to simulate an asynchronous receive operation
	// actually will return the previous contents of the buffer
	NKern::FMWait(&iLock);
	// The synchonisation is for illustrative purposes only - in a real driver we might make use of
	// the configution here, so this would need to be protected from concurrent modification.
	NKern::FMSignal(&iLock);
	iReadTimer.OneShot(KAsyncDelay, iCompleteReadDfc);
	}

void DExampleChannel::SendFromWriteBuffer()
	{
	// just queue a timer to simulate an asynchronous send operation
	NKern::FMWait(&iLock);
	// The synchonisation is for illustrative purposes only - in a real driver we might make use of
	// the configution here, so this would need to be protected from concurrent modification.
	NKern::FMSignal(&iLock);
	iWriteTimer.OneShot(KAsyncDelay, iCompleteWriteDfc);
	}

void DExampleChannel::ReceiveCompleteDfcFunc(TAny* aPtr)
	{
	DExampleChannel* self = (DExampleChannel*)aPtr;
	self->CompleteRead();
	}

void DExampleChannel::SendCompleteDfcFunc(TAny* aPtr)
	{
	DExampleChannel* self = (DExampleChannel*)aPtr;
	self->CompleteWrite();
	}

void DExampleChannel::CompleteRead()
	{
	TInt r;
	if (iReadDest)
		{
		r = Kern::ThreadRawWrite(iClient, iReadDest, iBuffer, iReadLength, iClient);
		iReadDest = NULL;
		}
	else
		{
		TPtrC8 des(iBuffer, iReadLength);
		r = Kern::ThreadDesWrite(iClient, iReadDes, des, 0, KChunkShiftBy0, iClient);
		iReadDes = NULL;
		}
	
	iReadLength = 0;
	Kern::RequestComplete(iClient, iReadStatus, r);
	}

void DExampleChannel::CompleteWrite()
	{
	TInt r;
	if (iWriteSrc)
		{
		r = Kern::ThreadRawRead(iClient, iWriteSrc, iBuffer, iWriteLength);
		iWriteSrc = NULL;
		}
	else
		{
		TPtr8 des(iBuffer, iWriteLength);
		r = Kern::ThreadDesRead(iClient, iWriteDes, des, 0);
		iWriteDes = NULL;
		}
	
	iWriteLength = 0;
	Kern::RequestComplete(iClient, iWriteStatus, r);
	}

//
// Logical device
//

class DExampleFactory : public DLogicalDevice
	{
public:
	DExampleFactory();
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

DExampleFactory::DExampleFactory()
	{
	iParseMask = 0;
	iVersion = TVersion(1, 0, 0);
	}

TInt DExampleFactory::Install()
	{
	return SetName(&KPagingExample2PreLdd);
	}

void DExampleFactory::GetCaps(TDes8& /*aDes*/) const
	{
	// not used but required as DLogicalDevice::GetCaps is pure virtual
	}

TInt DExampleFactory::Create(DLogicalChannelBase*& aChannel)
	{
	aChannel = new DExampleChannel;
	return aChannel ? KErrNone : KErrNoMemory;
	}

DECLARE_STANDARD_LDD()
	{
	return new DExampleFactory;
	}