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

// e32test\resourceman\d_rescontrolclisync.cpp

// 

//

#include <kernel/kern_priv.h>

#include <drivers/resource_extend.h>

#include <drivers/resourceman.h>

#include "d_rescontrolclisync.h"

#include "resourceman_psl/rescontrol_psl.h"

_LIT(KTestPowerRCName, "D_RESCONTROLCLISYNC.LDD");

const TInt KTestResManLddThreadPriority  = 0x5;

const TUint KResourceId = 16; // DMLSHLGLSPResource

const TInt KResourceMax = 65;

const TInt KResourceMin = 10;

_LIT(KTestResManLddThread, "TestResManLddThread");

_LIT(KTestResManLddHelperThread, "TestResManLddHelperThread");

_LIT(KTestResManLddCallbackThread, "TestResManLddCallbackThread");

_LIT(KResClientName1, "ResTestClient1");

_LIT(KResClientName2, "ResTestClient2");

class DTestResManLdd;

/**

The logical device (factory class) for the resource manager client side test.

*/

class DTestResManLddFactory : public DLogicalDevice

	{

public:

    enum {

        ESignallerCallback,

        EWaiterCallback

    };

	DTestResManLddFactory();

	~DTestResManLddFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

    NFastSemaphore iSemaphore1; // fast semaphore for helper queue

    NFastSemaphore iSemaphore2; // fast semaphore for call back thread

	TInt iResourceClientRegisterCount;

	TDynamicDfcQue* iLddQue;   // dfc que for logical channel (also running the primary ChangeResourceState

	TDynamicDfcQue* iLddHelperQue; // helper dfc que to execute the secondary ChangeResourceState

    TDynamicDfcQue* iCallbackQue;  // dfc que for call back 

    DTestResManLdd* iChannel1;

    DTestResManLdd* iChannel2;

    TInt iCallbackState;

    TPowerResourceCb* iAsyncResourceCallback; 

	};

/** Logical channel class for Resource manager test LDD */

class DTestResManLdd : public DLogicalChannel

	{

public:

	DTestResManLdd();

	virtual ~DTestResManLdd();

	// Inherited from DLogicalChannel

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual void HandleMsg(TMessageBase* aMsg);

    DThread* iClientThreadPtr;	

    TRequestStatus* iStatus;

    TUint iResClientId;

    TDfc* iWaitAndChangeResourceDfc;

private:

	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

	TInt DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2);

	TInt DoCancel(TUint aMask);

	};

void AsyncResourceCallbackFn(TUint /*aClientId*/, TUint /*aResourceId*/, TInt /*aLevel*/, TInt /*aLevelOwnerId*/, TInt aResult, TAny* aParam)

    {

    // call back function, always run on call back dfc queue

    Kern::Printf(">AsyncResourceCallbackFn 0x%x", &(Kern::CurrentThread().iNThread));

    DTestResManLddFactory* pLddFactory = (DTestResManLddFactory*)aParam;

    DTestResManLdd* pLdd = NULL;

    if(pLddFactory->iCallbackState == DTestResManLddFactory::ESignallerCallback)

        {

        pLdd = pLddFactory->iChannel1;

        Kern::Printf("AsyncResourceCallbackFn cond 1 signal [#3.1]"); 

        NKern::FSSignal(&(pLddFactory->iSemaphore1));

        Kern::Printf("AsyncResourceCallbackFn cond 1 wait [#3.2]");

        NKern::FSWait(&(pLddFactory->iSemaphore2));

        Kern::Printf("AsyncResourceCallbackFn cond 1 wake up [#3.3]");

        }

    else if(pLddFactory->iCallbackState == DTestResManLddFactory::EWaiterCallback)

        {

        pLdd = pLddFactory->iChannel2;

        // aResult should be equal to KErrNone (not KErrCompletion)

        Kern::Printf("AsyncResourceCallbackFn cond 2 r = %d [#2.5]", aResult);

        }

    else

        {

        Kern::Fault("AsyncResourceCallbackFn", __LINE__);

        }

    Kern::RequestComplete(pLdd->iClientThreadPtr, pLdd->iStatus, aResult);

    pLdd->iStatus = NULL;    

    Kern::Printf("<AsyncResourceCallbackFn");

    }

void WaitAndChangeResourceDfcFn(TAny* aLdd)

    {

    // helper function to call ChangeResourceState, always run on ldd helper dfc queue

    Kern::Printf(">WaitAndChangeResourceDfcFn 0x%x [#2.1]", &(Kern::CurrentThread().iNThread));

    DTestResManLdd* pLdd = (DTestResManLdd*)aLdd;

    DTestResManLddFactory* pLddFactory = (DTestResManLddFactory*)(pLdd->iDevice);

    Kern::Printf(" WaitAndChangeResourceDfcFn - Wait for Semaphore [#2.2]");

    NKern::FSWait(&(pLddFactory->iSemaphore1));

    Kern::Printf(" WaitAndChangeResourceDfcFn - ChangeResourceState [#2.3]");

    pLddFactory->iCallbackState = DTestResManLddFactory::EWaiterCallback;

    PowerResourceManager::ChangeResourceState(pLdd->iResClientId, KResourceId, KResourceMax, pLddFactory->iAsyncResourceCallback);

    Kern::Printf(" WaitAndChangeResourceDfcFn - signal [#2.4]");

    NKern::FSSignal(&(pLddFactory->iSemaphore2));

    delete pLdd->iWaitAndChangeResourceDfc;

    Kern::Printf("<WaitAndChangeResourceDfcFn");

    }

DTestResManLddFactory::DTestResManLddFactory()

	{

	iParseMask=0; // Allow info and pdd, but not units

	iUnitsMask=0;

	// Set version number for this device

	iVersion=RTestResMan::VersionRequired();

	}

DTestResManLddFactory::~DTestResManLddFactory()

	{

    if(iLddQue)

        iLddQue->Destroy();       

    if(iLddHelperQue)

      iLddHelperQue->Destroy(); 

    if(iCallbackQue)

      iCallbackQue->Destroy(); 

    if(iAsyncResourceCallback)

      delete iAsyncResourceCallback;

	}

/** Entry point for this driver */

DECLARE_STANDARD_LDD()

	{

	DTestResManLddFactory* p = new DTestResManLddFactory;

	if(!p)

		return NULL;

	TInt r = KErrNone;

    r = Kern::DynamicDfcQCreate(p->iLddQue, KTestResManLddThreadPriority, KTestResManLddThread);

    if(r != KErrNone)

        {

        return NULL;

        }

    Kern::Printf("iLddQue 0x%x", p->iLddQue->iThread);

    r = Kern::DynamicDfcQCreate(p->iLddHelperQue, KTestResManLddThreadPriority, KTestResManLddHelperThread);

    if(r != KErrNone)

        {

        p->iLddQue->Destroy();  

        return NULL;

        }

    p->iSemaphore1.iOwningThread = (NThreadBase*)(p->iLddHelperQue->iThread);

    Kern::Printf("iSemaphore1 owning thread 0x%x", p->iSemaphore1.iOwningThread);

    r = Kern::DynamicDfcQCreate(p->iCallbackQue, KTestResManLddThreadPriority, KTestResManLddCallbackThread);

    if(r != KErrNone)

        {

        p->iLddQue->Destroy();  

        p->iLddHelperQue->Destroy();          

        return NULL;

        }

    p->iSemaphore2.iOwningThread = (NThreadBase*)(p->iCallbackQue->iThread);

    Kern::Printf("iSemaphore2 owning thread 0x%x", p->iSemaphore2.iOwningThread);

    p->iAsyncResourceCallback = new TPowerResourceCb(AsyncResourceCallbackFn, p, 

            p->iCallbackQue, 5);    

#ifdef __SMP__      

    NKern::ThreadSetCpuAffinity((NThread*)(p->iLddQue->iThread), 0);

    NKern::ThreadSetCpuAffinity((NThread*)(p->iLddHelperQue->iThread), 0);

    NKern::ThreadSetCpuAffinity((NThread*)(p->iCallbackQue->iThread), 1);

#endif      

	r = DSimulatedPowerResourceController::CompleteResourceControllerInitialisation();

	if(r != KErrNone)

		Kern::Fault("PRM INIT FAILED", __LINE__);

	return p;

	}

/** Second stage constuctor */

TInt DTestResManLddFactory::Install()

	{

   	return(SetName(&KTestPowerRCName));

	}

/** Device capabilities */

void DTestResManLddFactory::GetCaps(TDes8& aDes)const

	{

	// Create a capabilities object

	RTestResMan::TCaps caps;

	caps.iVersion = iVersion;

	// Write it back to user memory

	Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));

	}

TInt DTestResManLddFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DTestResManLdd();

	if(!aChannel)

		return KErrNoMemory;

	if(!iChannel1)

	    iChannel1 = (DTestResManLdd*)aChannel;

	else if(!iChannel2)

	    iChannel2 = (DTestResManLdd*)aChannel;

	else

	    {

        delete aChannel;

	    return KErrInUse;

	    }

	return KErrNone;

	}

/** Constructor */

DTestResManLdd::DTestResManLdd()

	{

	iClientThreadPtr=&Kern::CurrentThread();

	iResClientId = 0;

	// Increase the DThread's ref count so that it does not close without us

	((DObject*)iClientThreadPtr)->Open();

	}

/** Destructor */

DTestResManLdd::~DTestResManLdd()

	{

	Kern::SafeClose((DObject*&)iClientThreadPtr,NULL);

	}

/** Second stage constructor. */

TInt DTestResManLdd::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

   	// Check version

	if (!Kern::QueryVersionSupported(RTestResMan::VersionRequired(),aVer))

		return KErrNotSupported;

	SetDfcQ(((DTestResManLddFactory*)iDevice)->iLddQue);

 	iMsgQ.Receive();

	return KErrNone;

	}

/** Process a message for this logical channel */

void DTestResManLdd::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		// Channel close.

		m.Complete(KErrNone,EFalse);

		return;

		}

	else if (id==KMaxTInt)

		{

		// DoCancel

		m.Complete(KErrNone,ETrue);

		return;

		}

	else if (id<0)

		{

		// DoRequest

		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

		TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2());

		if (r!=KErrNone)

			Kern::RequestComplete(iClientThreadPtr,pS,r);

		m.Complete(KErrNone,ETrue);

		}

	else

		{

		// DoControl

		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

		m.Complete(r,ETrue);

		}

	}

/**

  Process synchronous 'control' requests

*/

TInt DTestResManLdd::DoControl(TInt aFunction, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r = KErrNone;

	switch(aFunction)

		{

		case RTestResMan::ERegisterClient:

		    {

            Kern::Printf("RTestResMan::ERegisterClient");		    

			if(iResClientId!=0)

				{

				r = KErrInUse;

				break;

				}

			if(((DTestResManLddFactory*)iDevice)->iResourceClientRegisterCount==0)

			    {

			    r = PowerResourceManager::RegisterClient(iResClientId, KResClientName1);

			    }

			else if(((DTestResManLddFactory*)iDevice)->iResourceClientRegisterCount==1)

			    {

                r = PowerResourceManager::RegisterClient(iResClientId, KResClientName2);

                }                

			else

			    r = KErrInUse;

			(((DTestResManLddFactory*)iDevice)->iResourceClientRegisterCount)++;

			break;

		    }

	    case RTestResMan::EDeRegisterClient:

	        {

            Kern::Printf("RTestResMan::EDeRegisterClient");          

            if(iResClientId==0)

                {

                r = KErrArgument;

                break;

                }

            r = PowerResourceManager::DeRegisterClient(iResClientId);

            break;

	        }    

        case RTestResMan::EPrintResourceInfo:

            {

            Kern::Printf("RTestResMan::EPrintResourceInfo");          

            TPowerResourceInfoBuf01 info;

            info.SetLength(0);

            Kern::Printf("EPrintResourceInfo");

            r = PowerResourceManager::GetResourceInfo(iResClientId,KResourceId,&info);

            Kern::Printf("EPrintResourceInfo:%S", info().iResourceName);

            break;

            }

		default:

		    {

			r = KErrNotSupported;

			break;

		    }

		}

	return r;

	}

TInt DTestResManLdd::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r = KErrNone;

	if(r != KErrNone)

		Kern::RequestComplete(iClientThreadPtr, aStatus, r);

	switch(aReqNo)

		{

        case RTestResMan::EWaitAndChangeResource:

            // Queue a dfc which wait for the semaphore and then call ChangeResourceState

            Kern::Printf("RTestResMan::EWaitAndChangeResource 0x%x [#1.1]", &(Kern::CurrentThread().iNThread));            

            if(iStatus)

                {

                r = KErrInUse;

                break;

                }

            iStatus = aStatus;

            iWaitAndChangeResourceDfc = new TDfc(WaitAndChangeResourceDfcFn, this, 

                    ((DTestResManLddFactory*)iDevice)->iLddHelperQue, 5);

            iWaitAndChangeResourceDfc->Enque();

            break;

        case RTestResMan::EChangeResourceAndSignal:	

            // call ChangeResourceState and signal the semaphore

            Kern::Printf("RTestResMan::EChangeResourceAndSignal 0x%x [#1.2]", &(Kern::CurrentThread().iNThread));             

            if(iStatus)

                {

                r = KErrInUse;

                break;

                }

            iStatus = aStatus;

            PowerResourceManager::ChangeResourceState(iResClientId, KResourceId, KResourceMin, 

                    ((DTestResManLddFactory*)iDevice)->iAsyncResourceCallback);

            ((DTestResManLddFactory*)iDevice)->iCallbackState = DTestResManLddFactory::ESignallerCallback;

            break;            

	    default:

	        break;

		}

	return r;

	}