// 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_1_post.cpp
// Demand paging migration example device driver d_pagingexample_1_post: a DLogicalChannel-dervied
// driver, post-migration
// 
//

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

const TInt KDfcQThreadPriority = 25;
const TInt KBufferSize = KMaxTransferSize;

//
// Logical channel
//

class DExampleChannel : public DLogicalChannel
	{
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 SendMsg(TMessageBase* aMsg);
	TInt SendControl(TMessageBase* aMsg);
	TInt SendRequest(TMessageBase* aMsg);
	virtual void HandleMsg(TMessageBase* aMsg);
	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);
	void DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2);
	TInt DoCancel(TUint aMask);
private:
	TDfcQue* DfcQ();
	void Shutdown();
	void SetConfig(const TConfigData&);
	TInt PreNotify(TRequestStatus* aStatus);
	void StartNotify();
	TInt PreAsyncGetValue(TInt* aValue, TRequestStatus* aStatus);
	void StartAsyncGetValue();
	TInt PreAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus);
	void StartAsyncGetValue2();
	TInt PreRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);
	void StartRead();
	TInt PreReadDes(TDes8* aDesOut, TRequestStatus* aStatus);
	void StartReadDes();
	TInt PreWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);
	void StartWrite();
	TInt PreWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus);
	void StartWriteDes();
	void ReceiveToReadBuffer();
	void SendFromWriteBuffer();
	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();
private:
	TDynamicDfcQue* iDynamicDfcQ;
	TConfigData iConfig;
	DThread* iClient;
	
	// Notify
	TClientRequest* iNotifyRequest;
	
	// Async get value
	TClientDataRequest<TValueStruct>* iAsyncGetValueRequest;
	NTimer iAsyncGetValueTimer;
	TDfc iAsyncGetValueDfc;
	
	// Async get value 2
	TClientDataRequest2<TInt,TInt>* iAsyncGetValue2Request;
	NTimer iAsyncGetValue2Timer;
	TDfc iAsyncGetValue2Dfc;
	
	// Read
	TClientBufferRequest* iReadRequest;
	NTimer iReadTimer;
	TClientBuffer* iClientReadBuffer;
	TDfc iCompleteReadDfc;
	
	// Write
	TClientBufferRequest* iWriteRequest;
	NTimer iWriteTimer;
	TClientBuffer* iClientWriteBuffer;
	TDfc iCompleteWriteDfc;
	TUint8 iBuffer[KBufferSize];
	};

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

DExampleChannel::~DExampleChannel()
	{
	Kern::SafeClose((DObject*&)iClient, NULL);
	if (iDynamicDfcQ)
		iDynamicDfcQ->Destroy();
	Kern::DestroyClientRequest(iNotifyRequest);
	Kern::DestroyClientRequest(iAsyncGetValueRequest);
	Kern::DestroyClientRequest(iAsyncGetValue2Request);
	Kern::DestroyClientBufferRequest(iReadRequest);
	Kern::DestroyClientBufferRequest(iWriteRequest);
	}

TDfcQue* DExampleChannel::DfcQ()
	{
	return iDynamicDfcQ;
	}

TInt DExampleChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
	TInt r;
	
	r = Kern::CreateClientRequest(iNotifyRequest);
	if (r != KErrNone)
		return r;
	r = Kern::CreateClientDataRequest(iAsyncGetValueRequest);
	if (r != KErrNone)
		return r;
	r = Kern::CreateClientDataRequest2(iAsyncGetValue2Request);
	if (r != KErrNone)
		return r;
	r = Kern::CreateClientBufferRequest(iReadRequest, 1, TClientBufferRequest::EPinVirtual);
	if (r != KErrNone)
		return r;
	r = Kern::CreateClientBufferRequest(iWriteRequest, 1, TClientBufferRequest::EPinVirtual);
	if (r != KErrNone)
		return r;
	
	// create a dynamic DFC queue, which is used for handling client messages and for our own DFCs
	r = Kern::DynamicDfcQCreate(iDynamicDfcQ, KDfcQThreadPriority, KPagingExample1PostLdd);
	if (r != KErrNone)
		return r;

	// todo: this will be the default anyway
	iDynamicDfcQ->SetRealtimeState(ERealtimeStateOn);
	
	SetDfcQ(DfcQ());
	iAsyncGetValueDfc.SetDfcQ(DfcQ());
	iAsyncGetValue2Dfc.SetDfcQ(DfcQ());
	iCompleteReadDfc.SetDfcQ(DfcQ());
	iCompleteWriteDfc.SetDfcQ(DfcQ());
	iMsgQ.Receive();
	return KErrNone;
	}

// override SendMsg method to allow pinning data in the context of the client thread
TInt DExampleChannel::SendMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id = m.iValue;

	// we only support one client
	if (id != (TInt)ECloseMsg && m.Client() != iClient)
		return KErrAccessDenied;
	
	TInt r = KErrNone;
	if (id != (TInt)ECloseMsg && id != KMaxTInt)
		{
		if (id<0)
			{
			TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
			r = SendRequest(aMsg);
			if (r != KErrNone)
				Kern::RequestComplete(pS,r);
			}
		else
			r = SendControl(aMsg);
		}
	else
		r = DLogicalChannel::SendMsg(aMsg);
	
	return r;
	}

void DExampleChannel::HandleMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id=m.iValue;
	
	if (id==(TInt)ECloseMsg)
		{
		Shutdown();
		m.Complete(KErrNone,EFalse);
		return;
		}
    else if (id==KMaxTInt)
		{
		// DoCancel
		DoCancel(m.Int0());
		m.Complete(KErrNone,ETrue);
		return;
		}
    else if (id<0)
		{
		// DoRequest
		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
		DoRequest(~id,pS,m.Ptr1(),m.Ptr2());
		m.Complete(KErrNone,ETrue);
		}
    else
		{
		// DoControl
		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());
		m.Complete(r,ETrue);
		}
	}
	
TInt DExampleChannel::SendControl(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id=m.iValue;

	// thread-local copy of configuration data
	TConfigData kernelConfigBuffer;
	TAny* userConfigPtr = m.Ptr0();
	
	switch (id)
		{
		case RPagingExample::ESetConfig:
			// copy config from client to local buffer in context of client thread
			umemget32(&kernelConfigBuffer, userConfigPtr, sizeof(TConfigData));
			// update message to point to kernel-side buffer
			m.iArg[0] = &kernelConfigBuffer;
			break;
			
		case RPagingExample::EGetConfig:
			// update message to point to kernel-side buffer
			m.iArg[0] = &kernelConfigBuffer;
			break;
		}

	TInt r = DLogicalChannel::SendMsg(aMsg);
	if (r != KErrNone)
		return r;

	switch (id)
		{
		case RPagingExample::EGetConfig:
			// copy config from local bufferto client in context of client thread
			umemput32(userConfigPtr, &kernelConfigBuffer, sizeof(TConfigData));
			break;
		}

	return r;
	}

TInt DExampleChannel::DoControl(TInt aFunction,TAny* a1,TAny* /*a2*/)
	{
	TInt r = KErrNone;
	TConfigData* configBuffer = (TConfigData*)a1;
	switch (aFunction)
		{
		case RPagingExample::EGetConfig:
			// copy current config into local buffer in context of DFC thread to avoid potential race conditions
			*configBuffer = iConfig;
			break;

		case RPagingExample::ESetConfig:
			// set config from copy in local buffer in context of DFC thread to avoid potential race conditions
			SetConfig(*configBuffer);
			break;

		default:
			r = KErrNotSupported;
		}
	return r;
	}

TInt DExampleChannel::SendRequest(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt function = ~m.iValue;
	TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
	TAny* a1 = m.Ptr1();
	TAny* a2 = m.Ptr2();
		
	TInt r = KErrNotSupported;
	switch (function)
		{
		case RPagingExample::ERequestNotify:
			r = PreNotify(pS);
			break;

		case RPagingExample::ERequestAsyncGetValue:
			r = PreAsyncGetValue((TInt*)a1, pS);
			break;

		case RPagingExample::ERequestAsyncGetValue2:
			r = PreAsyncGetValue2((TInt*)a1, (TInt*)a2, pS);
			break;
			
		case RPagingExample::ERequestRead:
			r = PreRead(a1, (TInt)a2, pS);
			break;
			
		case RPagingExample::ERequestReadDes:
			r = PreReadDes((TDes8*)a1, pS);
			break;

		case RPagingExample::ERequestWrite:
			r = PreWrite(a1, (TInt)a2, pS);
			break;
			
		case RPagingExample::ERequestWriteDes:
			r = PreWriteDes((TDes8*)a1, pS);
			break;
		}

	if (r == KErrNone)
		r = DLogicalChannel::SendMsg(aMsg);
	return r;
	}

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

		case RPagingExample::ERequestWrite:
			StartWrite();
			break;
			
		case RPagingExample::ERequestWriteDes:
			StartWriteDes();
			break;

		default:
			__NK_ASSERT_ALWAYS(EFalse);  // we already validated the request number
		}
	}

TInt DExampleChannel::DoCancel(TUint /*aMask*/)
	{
	if (iAsyncGetValueRequest->IsReady())	
		{
		iAsyncGetValueTimer.Cancel();
		iAsyncGetValueDfc.Cancel();
		Kern::QueueRequestComplete(iClient, iAsyncGetValueRequest, KErrCancel);
		}
	
	if (iAsyncGetValue2Request->IsReady())
		{
		iAsyncGetValue2Timer.Cancel();
		iAsyncGetValue2Dfc.Cancel();
		Kern::QueueRequestComplete(iClient, iAsyncGetValue2Request, KErrCancel);
		}
	
	if (iReadRequest->IsReady())
		{
		iReadTimer.Cancel();
		iCompleteReadDfc.Cancel();
		Kern::QueueBufferRequestComplete(iClient, iReadRequest, KErrCancel);
		}
	
	if (iWriteRequest->IsReady())
		{
		iWriteTimer.Cancel();
		iCompleteWriteDfc.Cancel();
		Kern::QueueBufferRequestComplete(iClient, iWriteRequest, KErrCancel);
		}
	
	return KErrNone;
	}

void DExampleChannel::Shutdown()
	{
	}

void DExampleChannel::SetConfig(const TConfigData& aNewConfig)
	{
	iConfig = aNewConfig;
	}

TInt DExampleChannel::PreNotify(TRequestStatus* aStatus)
	{
	return iNotifyRequest->SetStatus(aStatus);
	}

void DExampleChannel::StartNotify()
	{
	CompleteNotify(); // example implementation completes the request immediately
	}

void DExampleChannel::CompleteNotify()
	{
	Kern::QueueRequestComplete(iClient, iNotifyRequest, KErrNone);
	}

TInt DExampleChannel::PreAsyncGetValue(TInt* aValue, TRequestStatus* aStatus)
	{
	TInt r = iAsyncGetValueRequest->SetStatus(aStatus);
	if (r != KErrNone)
		return r;
	iAsyncGetValueRequest->SetDestPtr(aValue);
	return KErrNone;
	}

void DExampleChannel::StartAsyncGetValue()
	{
	// queue a timer to simulate an asynchronous operation
	iAsyncGetValueTimer.OneShot(KAsyncDelay, iAsyncGetValueDfc);
	}

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

void DExampleChannel::CompleteAsyncGetValue()
	{
	iAsyncGetValueRequest->Data().iValue1 = 1;
	iAsyncGetValueRequest->Data().iValue2 = _L8("shrt");
	Kern::QueueRequestComplete(iClient, iAsyncGetValueRequest, KErrNone);
	}

TInt DExampleChannel::PreAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus)
	{
	TInt r = iAsyncGetValue2Request->SetStatus(aStatus);
	if (r != KErrNone)
		return r;
	iAsyncGetValue2Request->SetDestPtr1(aValue1);
	iAsyncGetValue2Request->SetDestPtr2(aValue2);
	return KErrNone;
	}

void DExampleChannel::StartAsyncGetValue2()
	{
	// queue a timer to simulate an asynchronous operation
	iAsyncGetValue2Timer.OneShot(KAsyncDelay, iAsyncGetValue2Dfc);
	}

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

void DExampleChannel::CompleteAsyncGetValue2()
	{
	iAsyncGetValue2Request->Data1() = 1;
	iAsyncGetValue2Request->Data2() = 2;
	Kern::QueueRequestComplete(iClient, iAsyncGetValue2Request, KErrNone);
	}

TInt DExampleChannel::PreRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)
	{
	// check length argument first
	if (aLength < 1 || aLength > KBufferSize)
		return KErrArgument;

	// start request setup
	TInt r = iReadRequest->StartSetup(aStatus);
	if (r != KErrNone)
		return r;
	
	// add client buffer, this does pinning in context of client thread
	r = iReadRequest->AddBuffer(iClientReadBuffer, (TLinAddr)aBuffer, aLength, ETrue);
	if (r != KErrNone)
		return KErrNoMemory;

	iReadRequest->EndSetup();
	return KErrNone;
	}

void DExampleChannel::StartRead()
	{	
	ReceiveToReadBuffer(); // called in DFC thread as may require serialised access to hardware
	}

TInt DExampleChannel::PreReadDes(TDes8* aDesOut, TRequestStatus* aStatus)
	{
	// start request setup
	TInt r = iReadRequest->StartSetup(aStatus);
	if (r != KErrNone)
		return r;

	// add client descriptor, this does pinning in context of client thread
	r = iReadRequest->AddBuffer(iClientReadBuffer, aDesOut);
	if (r != KErrNone)
		return r;

	// can check length argument here
	TInt length = iClientReadBuffer->MaxLength();
	if (length < 1 || length > KBufferSize)
		{
		// need to reset object so it can be reused
		iReadRequest->Reset();
		return KErrArgument;
		}

	iReadRequest->EndSetup();	
	return KErrNone;
	}

void DExampleChannel::StartReadDes()
	{
	ReceiveToReadBuffer(); // called in DFC thread as may require serialised access to hardware
	}

TInt DExampleChannel::PreWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)
	{
	// check length argument first
	if (aLength < 1 || aLength > KBufferSize)
		return KErrArgument;

	// demonstrate use the single-buffer version of Setup
	return iWriteRequest->Setup(iClientWriteBuffer, aStatus, (TLinAddr)aBuffer, aLength);
	}

void DExampleChannel::StartWrite()
	{
	SendFromWriteBuffer(); // called in DFC thread as may require serialised access to hardware
	}

TInt DExampleChannel::PreWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus)
	{
	// demonstrate use the single-buffer version of Setup
	TInt r = iWriteRequest->Setup(iClientWriteBuffer, aStatus, (TAny*)aDesIn);
	if (r != KErrNone)
		return r;

	// can check length argument here
	TInt length = iClientWriteBuffer->Length();
	if (length < 1 || length > KBufferSize)
		{
		// need to reset object so it can be reused
		iWriteRequest->Reset();
		return KErrArgument;
		}
	
	return KErrNone;
	}

void DExampleChannel::StartWriteDes()
	{
	SendFromWriteBuffer(); // called in DFC thread as may require serialised access to hardware
	}

void DExampleChannel::ReceiveToReadBuffer()
	{
	// just queue a timer to simulate an asynchronous receive operation
	// actually will return the previous contents of the buffer
	iReadTimer.OneShot(KAsyncDelay, iCompleteReadDfc);
	}

void DExampleChannel::SendFromWriteBuffer()
	{
	// just queue a timer to simulate an asynchronous send operation
	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()
	{
	TPtrC8 des(iBuffer, iClientReadBuffer->MaxLength());
	TInt r = Kern::ThreadBufWrite(iClient, iClientReadBuffer, des, 0, KChunkShiftBy0, iClient);
	Kern::QueueBufferRequestComplete(iClient, iReadRequest, r);
	}

void DExampleChannel::CompleteWrite()
	{
	TPtr8 des(iBuffer, iClientWriteBuffer->Length());
	TInt r = Kern::ThreadBufRead(iClient, iClientWriteBuffer, des, 0, KChunkShiftBy0);
	Kern::QueueBufferRequestComplete(iClient, iWriteRequest, 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(&KPagingExample1PostLdd);
	}

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;
	}