// Copyright (c) 1995-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\drivers\resmanus\d_resmanus.cpp

// 

//

// LDD for Resource Manager user side API

#include "resmanus.h"

#include <kernel/kern_priv.h>

#include <kernel/kernel.h>

#include <e32hal.h>

#include <e32uid.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <e32def_private.h>

#include <drivers/resource_extend.h>

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

#include "rescontrol_psl.h"

#endif

#ifdef PRM_US_INSTRUMENTATION_MACRO

#include <drivers/resmanus_trace.h>

#endif

#ifdef PRM_ENABLE_EXTENDED_VERSION2

_LIT(KResManUsThreadName,"ResManUsExtendedCoreLddThread");

#elif defined (PRM_ENABLE_EXTENDED_VERSION)

_LIT(KResManUsThreadName,"ResManUsExtendedLddThread");

#else

_LIT(KResManUsThreadName,"ResManUsLddThread");

#endif

#define RESMANUS_FAULT()	Kern::Fault("RESMANUS",__LINE__)

const TInt KResManUsThreadPriority = 24;

const TInt KResManUsRegistrationPriority = 5; // Arbitrary! Can be 0-7, 7 is highest

const TInt KResManCallBackPriority = 5; // Arbitrary! Can be 0-7, 7 is highest

//Macro to return appropriate request type.

#define GET_USER_REQUEST(request, buffer, type)						\

	{																\

	if(type == EGetState)											\

		request = ((TTrackGetStateBuf*)buffer)->iRequest;			\

	else if(type == ESetState)										\

		request = ((TTrackSetStateBuf*)buffer)->iRequest;			\

	else															\

		request = ((TTrackNotifyBuf*)buffer)->iRequest;				\

	}

/***************************************************************************************

	class TTrackGetStateBuf

 ***************************************************************************************/

TTrackGetStateBuf::TTrackGetStateBuf(TPowerResourceCbFn aFn, TAny* aPtr,

						       TDfcQue* aQue, TInt aPriority)

							   :	iCtrlBlock(aFn, aPtr, aQue, aPriority)

	{

	iRequest = NULL;

	}

/***************************************************************************************

	class TTrackSetStateBuf

 ***************************************************************************************/

TTrackSetStateBuf::TTrackSetStateBuf(TPowerResourceCbFn aFn, TAny* aPtr,

						       TDfcQue* aQue, TInt aPriority)

							   :	iCtrlBlock(aFn, aPtr, aQue, aPriority)

	{

	iRequest = NULL;

	}

/***************************************************************************************

	class TTrackNotifyBuf

 ***************************************************************************************/

TTrackNotifyBuf::TTrackNotifyBuf(TPowerResourceCbFn aFn, TAny* aPtr,

								 TDfcQue* aQue, TInt aPriority)

							   :	iNotifyBlock(aFn, aPtr, aQue, aPriority)

	{

	iRequest = NULL;

	}

TTrackNotifyBuf::~TTrackNotifyBuf()

	{

	if(iRequest)

		Kern::DestroyClientRequest(iRequest);

	}

TTrackSetStateBuf::~TTrackSetStateBuf()

	{

	if(iRequest)

		Kern::DestroyClientRequest(iRequest);

	}

TTrackGetStateBuf::~TTrackGetStateBuf()

	{

	if(iRequest)

		Kern::DestroyClientRequest(iRequest);

	}

/***************************************************************************************

	class DDeviceResManUs

 ***************************************************************************************/

DDeviceResManUs::DDeviceResManUs()

// Constructor

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceResManUs::DDeviceResManUs()"));

    iParseMask=KDeviceAllowAll&~KDeviceAllowUnit; // Allow info and pdd, but not units

    iUnitsMask=0;

    iVersion=TVersion(KResManUsMajorVersionNumber,

		      KResManUsMinorVersionNumber,

		      KResManUsBuildVersionNumber);

    }

DDeviceResManUs::~DDeviceResManUs()

// Destructor

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceResManUs::~DDeviceResManUs()"));

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

	iSharedDfcQue->Destroy();

#else

	delete iSharedDfcQue;

#endif

	}

TInt DDeviceResManUs::Install()

// Install the device driver.

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceResManUs::Install()"));

	// Create the message queue and initialise the DFC queue pointer

#ifndef RESOURCE_MANAGER_SIMULATED_PSL

	TInt r=Kern::DfcQInit(iSharedDfcQue,KResManUsThreadPriority,&KResManUsThreadName);

#else

	TInt r = Kern::DynamicDfcQCreate(iSharedDfcQue,KResManUsThreadPriority,KResManUsThreadName);

#endif

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DfcQCreate r  = %d", r));

	if(r!=KErrNone)

		return r;

#ifdef CPU_AFFINITY_ANY

        NKern::ThreadSetCpuAffinity((NThread*)(iSharedDfcQue->iThread), KCpuAffinityAny);

#endif

	r = SetName(&KLddRootName);

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> SetName, r  = %d", r));

	return r;

    }

void DDeviceResManUs::GetCaps(TDes8& aDes) const

// Return the ResManUs capabilities.

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceResManUs::GetCaps(TDes8& aDes) const"));

    TPckgBuf<TCapsDevResManUs> b;

    b().version=TVersion(KResManUsMajorVersionNumber,

			 KResManUsMinorVersionNumber,

			 KResManUsBuildVersionNumber);

    Kern::InfoCopy(aDes,b);

    }

TInt DDeviceResManUs::Create(DLogicalChannelBase*& aChannel)

// Create a channel on the device.

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceResManUs::Create(DLogicalChannelBase*& aChannel)"));

	if(iOpenChannels>=KMaxNumChannels)

		return KErrOverflow;

    aChannel=new DChannelResManUs;

    return aChannel?KErrNone:KErrNoMemory;

    }

/***************************************************************************************

	class DChannelResManUs

 ***************************************************************************************/

DChannelResManUs::DChannelResManUs() 

// Constructor

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DChannelResManUs::DChannelResManUs()"));

    iClient=&Kern::CurrentThread();

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

	iClient->Open();

    }

DChannelResManUs::~DChannelResManUs()

// Destructor

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DChannelResManUs::~DChannelResManUs()"));

	// Cancel any outstanding requests

	//

	// For each tracker (Get, Set and notify)

	// 

	if(iGetStateTracker != NULL)

		{

		CancelTrackerRequests(iGetStateTracker,EFalse,0,NULL); // EFalse,0, to ignore resource IDs

		RemoveTrackingControl(iGetStateTracker);

		}

	if(iSetStateTracker != NULL)

		{

		CancelTrackerRequests(iSetStateTracker,EFalse,0,NULL); // EFalse,0, to ignore resource IDs

		RemoveTrackingControl(iSetStateTracker);

		}

	if(iListenableTracker != NULL)

		{

		CancelTrackerRequests(iListenableTracker,EFalse,0,NULL); // EFalse,0, to ignore resource IDs

		RemoveTrackingControl(iListenableTracker);

		}

	delete iUserNameUsed;

	delete iResourceDependencyIds;

	delete iClientNamesResCtrl;

	delete iResourceInfoResCtrl;

	// decrement the DThread's reference count

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

    }

static void AsyncCallBackFn(TUint aClient, TUint aResourceId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aTrackingBuffer)

	{

// Callback function for asynchronous requests

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> AsyncCallBackFn aClient=0x%x aResourceId=0x%x, aLevel=0x%x, aResult=0x%x, aTrackingBuffer=0x%x\n",aClient, aResourceId, aLevel, aResult, aTrackingBuffer));

	TTrackingBuffer* buffer = ((TTrackingBuffer*)aTrackingBuffer);

	TTrackingControl* tracker = buffer->GetTrackingControl();

	__ASSERT_ALWAYS((tracker!=NULL),RESMANUS_FAULT());

	DChannelResManUs* channel = tracker->iOwningChannel;

#ifdef PRM_US_INSTRUMENTATION_MACRO

	if(tracker->iType==EGetState)

		{

		PRM_US_GET_RESOURCE_STATE_END_TRACE;

		}

	else if(tracker->iType==ESetState)

		{

		PRM_US_SET_RESOURCE_STATE_END_TRACE;

		}

#endif

	if(tracker->iType == EGetState)

		{

		TTrackGetStateBuf* stateBuf = (TTrackGetStateBuf*)aTrackingBuffer;

		if(aResult==KErrNone)

			{

			// Write the state value to the user-supplied variable

			stateBuf->iRequest->Data1() = aLevel;

			stateBuf->iRequest->Data2() = aLevelOwnerId;

			}

		Kern::QueueRequestComplete(channel->iClient, ((TTrackGetStateBuf*)buffer)->iRequest, aResult);

		}

	else if(tracker->iType == ESetState)

		{

		Kern::QueueRequestComplete(channel->iClient, ((TTrackSetStateBuf*)buffer)->iRequest, aResult);

		}

	// Once notified of a change in a resource state, must cancel the notification

	// request in the Resource Controller to give the client the appearance of a 

	// 'one'shot' type of operation.

	else if(tracker->iType==ENotify)

		{

#ifdef PRM_ENABLE_EXTENDED_VERSION

		if(((TInt)aClient==KDynamicResourceDeRegistering)&&(aResourceId&KIdMaskDynamic))  

			{

			// Resource has de-registered from Resource Controller, so can't expect any more notifications

			// of this type. Cancellation of notifications (i.e. invoke Resource Controller) and transfer of

			// buffers to free queue (for both conditional and unconditional notifications) is already done.

			// To distinguish removal of a dynamic resource, hijack aResult (the value used when completing

			// the user-side TRequestStatus object) and set it to KErrDisconnected.

			aResult = KErrDisconnected;

			}

#endif

		TInt r = (channel->iPddPtr)->CancelNotification(channel->ClientHandle(),aResourceId,

										((TTrackNotifyBuf*)buffer)->iNotifyBlock);

		__ASSERT_ALWAYS((r == KErrCancel),RESMANUS_FAULT());

		Kern::QueueRequestComplete(channel->iClient, ((TTrackNotifyBuf*)buffer)->iRequest, aResult);

		}

	// Return the tracking buffer to the free queue

	channel->FreeTrackingBuffer(buffer);

	}

TInt DChannelResManUs::GetValidName(const TDesC8* aInfo)

	{

// Extract a usable name from that supplied by the client

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DChannelResManUs::GetValidName"));

	TInt err=KErrNone;

	if(aInfo)

		{

		DThread* thread = &Kern::CurrentThread();

		TInt nameLen = Kern::ThreadGetDesLength(thread, aInfo);

		if(nameLen<0)

			return nameLen; // return error code

		iNameProvidedLength = nameLen;

		if(nameLen > MAX_CLIENT_NAME_LENGTH)

			err=KErrBadName;

		else

			{

			nameLen = (nameLen<=MAX_NAME_LENGTH_IN_RESMAN) ? nameLen : MAX_NAME_LENGTH_IN_RESMAN;

			if((iUserNameUsed = HBuf8::New(nameLen))==NULL)

				return KErrNoMemory;

			err = Kern::ThreadDesRead(thread,aInfo,*iUserNameUsed,0);

			if(err!=KErrNone)

				return err;

			}

		}

	else

		err=KErrBadName;

	return err;

	}

TInt DChannelResManUs::RequestUserHandle(DThread* aThread, TOwnerType aType)

// Called when a user thread requests a handle to this channel

    {

    // Make sure that only our client can get a handle

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DChannelResManUs::RequestUserHandle"));

    if (aType!=EOwnerThread || aThread!=iClient)

        return KErrAccessDenied;

    return KErrNone;

    }

void DChannelResManUs::RegistrationDfcFunc(TAny* aChannel)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DChannelResManUs::RegistrationDfcFunc"));

	// DFC function invoked for registration with Resource Controller

	DChannelResManUs* channel = (DChannelResManUs*)aChannel;

	// RegisterProxyClient(TUint& aProxyId, const TDesC& aName);

	TUint uintVal=0;

	TInt r = KErrNone;

	__ASSERT_ALWAYS((r==KErrNone),RESMANUS_FAULT());

	r=(channel->iPddPtr)->RegisterProxyClient(uintVal,*((TDesC8*)(channel->iUserNameUsed)));

	if(r!=KErrNone)

		{

		// Registration failed

		// Ensure that the client-side flag is cleared in uintVal

		// so the failure can be detected in DoCreate

		uintVal &= ~USER_SIDE_CLIENT_BIT_MASK; // Copied from rescontrol_export

		}

	channel->SetClientHandle((TInt)uintVal);

	NKern::FSSignal(channel->iFastSem);

	}

TInt DChannelResManUs::RegisterWithResCtrlr()

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DChannelResManUs::RegisterWithResCtrlr"));

	TInt r = KErrNone;

	// Initialise the channel's fast semaphore

	iFastSem = new NFastSemaphore();

	if(iFastSem == NULL)

		r = KErrNoMemory;

	else

		{

		iFastSem->iOwningThread = (NThreadBase*)NKern::CurrentThread();

		// Attempt to perform registration with the Resource Controller on behalf of the client.

		SetDfcQ(((DDeviceResManUs*)(iDevice))->iSharedDfcQue);

		TDfc tempDfc(RegistrationDfcFunc, this, iDfcQ, KResManUsRegistrationPriority);

		// Block this thread until the DFC has executed

		tempDfc.Enque();

		NKern::FSWait(iFastSem);

		// Have finished with iFastSem

		delete iFastSem;

		// Registration complete - check success

		if(!(USER_SIDE_CLIENT_BIT_MASK & ClientHandle()))

			{

			// Registration failed

			r = KErrCouldNotConnect;	

			}

		// Start receiving messages ...

		iMsgQ.Receive();

		}

	return r;

	}

TInt DChannelResManUs::DoCreate(TInt /*aUnit*/,

                                const TDesC8* aInfo, 

                                const TVersion &aVer)

// Create the channel from the passed info.

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DChannelResManUs::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion &aVer)"));

	TInt r = KErrNone;

	iPddPtr = ((DUserSideProxyInterface*)iPdd)->iController;

	// Check client has appropriate capabilities

	if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by DDevicePowerRsrc::Create")))

		return KErrPermissionDenied;

	// Check software version

	if (!Kern::QueryVersionSupported(TVersion(KResManUsMajorVersionNumber,

			 KResManUsMinorVersionNumber,

			 KResManUsBuildVersionNumber),

				     aVer))

		return KErrNotSupported;

	// Implementation note: if this method fails, the destructor will be invoked

	// as part of which all successfully-allocated memory will be freed. Therefore,

	// no memory will be explicitly freed in the event of failure in the code which follows.

	// Allocate the arrays used for acquiring client, resource and dependency information

	if((iClientNamesResCtrl = HBuf8::New(KNumClientNamesResCtrl * sizeof(TPowerClientInfoV01)))==NULL)

		return KErrNoMemory;

	if((iResourceInfoResCtrl = HBuf8::New(KNumResourceInfoResCtrl * sizeof(TPowerResourceInfoV01)))==NULL)

		return KErrNoMemory;

	if((iResourceDependencyIds = HBuf8::New(KNumResourceDependencies * sizeof(SResourceDependencyInfo)))==NULL)

		return KErrNoMemory;

	// Obtain the channel name to use

	if((r=GetValidName(aInfo))!=KErrNone)

		return r;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	iResDepsValid = 0;

#endif

#ifdef PRM_US_INSTRUMENTATION_MACRO

	PRM_US_OPEN_CHANNEL_START_TRACE;	 

#endif

	// Set up the request tracking support

	iGetStateTracker = new TTrackingControl();

	iSetStateTracker = new TTrackingControl();;

	iListenableTracker = new TTrackingControl();

	if((iGetStateTracker==NULL) || (iSetStateTracker==NULL) || (iListenableTracker==NULL))

		return KErrNoMemory;

	// Register with the Resource Controller

	r = RegisterWithResCtrlr();

#ifdef PRM_US_INSTRUMENTATION_MACRO

	PRM_US_OPEN_CHANNEL_END_TRACE;

#endif

    return r;

    }

//Override sendMsg to allow data copy in the context of client thread for WDP.

TInt DChannelResManUs::SendMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	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;

	}

TInt DChannelResManUs::SendRequest(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = ~m.iValue;

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

	TInt r = KErrNone;

	TTrackingBuffer *trackBuf = NULL;

	TUint parms[4];

	TPowerResourceCb *callBack;

	DPowerResourceNotification *prn;

	switch(id)

		{

		case RBusDevResManUs::EChangeResourceState:

			{

			__ASSERT_ALWAYS(m.Ptr2() != NULL, RESMANUS_FAULT());

#ifdef _DUMP_TRACKERS

			if((r=DumpTracker(iSetStateTracker))!=KErrNone)

				break;

#endif

			r = GetAndInitTrackingBuffer(iSetStateTracker, trackBuf, (TUint)m.Ptr1(), pS);

			if( r != KErrNone)

				return r;

			callBack = &(((TTrackSetStateBuf*)trackBuf)->iCtrlBlock);

			new (callBack) TPowerResourceCb(&AsyncCallBackFn, (TAny*)trackBuf, iDfcQ, KResManCallBackPriority);

			parms[0] = (TUint)m.Ptr2();

			parms[1] = (TUint)callBack;

			m.iArg[2] = &(parms[0]);

			break;

			}

		case RBusDevResManUs::EGetResourceState:

			{

			__ASSERT_ALWAYS(m.Ptr2() != NULL, RESMANUS_FAULT());

			umemget32(&(parms[0]), m.Ptr2(), 3*sizeof(TInt));

#ifdef _DUMP_TRACKERS

			if((r=DumpTracker(iGetStateTracker))!=KErrNone)

				break;

#endif

			r = GetStateBuffer(iGetStateTracker, trackBuf, (TUint)m.Ptr1(), (TInt*)parms[1], (TInt*)parms[2], callBack, pS);

			if(r != KErrNone)

				return r;

			parms[3] = (TUint)callBack;

			m.iArg[2] = &(parms[0]);

			break;

			}

		case RBusDevResManUs::ERequestChangeNotification:

			{

			__ASSERT_ALWAYS(m.Ptr1() != NULL, RESMANUS_FAULT());

			r = GetAndInitTrackingBuffer(iListenableTracker, trackBuf, (TUint)m.Ptr1(), pS);

			if(r != KErrNone)

				return r;

			prn = &(((TTrackNotifyBuf*)trackBuf)->iNotifyBlock);

			new (prn) DPowerResourceNotification(&AsyncCallBackFn, (TAny*)trackBuf, iDfcQ, KResManCallBackPriority);

			m.iArg[2] = (TAny*)prn;

			break;

			}

		case RBusDevResManUs::ERequestQualifiedChangeNotification:

			{

			__ASSERT_ALWAYS(m.Ptr1() != NULL, RESMANUS_FAULT());

			__ASSERT_ALWAYS(m.Ptr2() != NULL, RESMANUS_FAULT());

			umemget32(&(parms[0]), m.Ptr2(), 2*sizeof(TUint));