1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\resourceman\d_rescontrol_cli.cpp

    15 // 

    16 //

    17 

    18 #include <kernel/kern_priv.h>

    19 #include <drivers/resource_extend.h>

    20 #include <drivers/resourceman.h>

    21 #include "d_rescontrolcli.h"

    22 #ifdef PRM_ENABLE_EXTENDED_VERSION

    23 #include "dynamicresource.h"

    24 #endif

    25 #include "./resourceman_psl/rescontrol_psl.h"

    26 

    27 #ifndef PRM_ENABLE_EXTENDED_VERSION

    28 _LIT(KTestPowerRCName, "D_RESCONTROLCLI.LDD");

    29 #else

    30 _LIT(KTestPowerRCName, "D_EXTENDEDRESCONTROLCLI.LDD");

    31 #endif

    32 

    33 const TInt KTestResManLddThreadPriority  = 0x5;

    34 _LIT(KTestResManLddThread, "TestResManLddThread");

    35 

    36 #ifdef PRM_ENABLE_EXTENDED_VERSION

    37 #define EXPECTED_POST_NOTI_COUNT 6 //Expected number of notifications as a result of post boot level setting. 

    38 #else

    39 #define EXPECTED_POST_NOTI_COUNT 5

    40 #endif

    41 #define MAX_DYNAMIC_RES_NUM 5

    42 /** 

    43 Structure for holding resource information

    44 */

    45 struct SClientInfo

    46 	{

    47 	HBuf8* pName;

    48 	TUint iClientId;

    49 	};

    50 /**

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

    52 */

    53 class DTestResManLddFactory : public DLogicalDevice

    54 	{

    55 public:

    56 	DTestResManLddFactory();

    57 	~DTestResManLddFactory();

    58 	virtual TInt Install();

    59 	virtual void GetCaps(TDes8 &aDes) const;

    60 	virtual TInt Create(DLogicalChannelBase*& aChannel);

    61 	static void PostBootNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

    62 	void SetPostBootLevelAndRequestNotification(TUint aClientId, TUint aResId, TInt aPostBootLevel);

    63 	TDynamicDfcQue* iDfcQ;

    64 	DStaticPowerResource *iStaticRes;

    65 	DStaticPowerResource *iStaticResArray[3];

    66 	static SClientInfo iClient; //Need to be static to access them in PostBootNotificationFunc (callback function).

    67 	static TUint iPostBootNotiCount;

    68 	};

    69 

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

    71 class DTestResManLdd : public DLogicalChannel

    72 	{

    73 public:

    74 	DTestResManLdd();

    75 	virtual ~DTestResManLdd();

    76 	// Inherited from DLogicalChannel

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

    78 	virtual void HandleMsg(TMessageBase* aMsg);

    79 private:

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

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

    82 	TInt DoCancel(TUint aMask);

    83 	static void CallbackFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

    84 	static void CondNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

    85 	static void UnCondNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

    86 private:

    87    	DThread* iClientThreadPtr;

    88    	TPowerResourceCb iAsyncResourceCallback; //Callback object for handling long latency resources.

    89 	//Structure for storing the notification information

    90 	struct SNotificationList

    91 		{

    92 		TUint iClientId;

    93 		TUint iResourceId;

    94 		TUint iCount;

    95 		DPowerResourceNotification *iNoti;

    96 		SNotificationList *iNext;

    97 		};

    98 	SNotificationList *iCondList; //List for maintaining conditional notification

    99 	SNotificationList *iUnCondList; //List for maintaining unconditional notification

   100 	TRequestStatus *iStatus; //Store the status and complete on callback function.

   101 	TBool iCallbackCancel; 

   102 	TInt iClientId; //ID of the client that requested long latency operation, to compare in callback and notifications.

   103 	TUint iResourceId; //Id of the resource of long latency operation, to compare in callback and notifications.

   104 	//Below 2 variables are used only for asynchronous get resource state operation

   105 	TInt *iStatePtr; //Pointer to hold the address of state variable, where state is updated in callback function.

   106 	TInt *iLevelOwnerIdPtr; //Pointer to hold the address of level owner Id variable, where owner Id is updated in callback function.

   107 	HBuf *pBuf; //Buffer for testing caching of resource information for Idle power management 

   108 	SClientInfo clientInfo[MAX_CLIENTS];

   109 #ifdef PRM_ENABLE_EXTENDED_VERSION

   110 	TUint iTestParallelResourceId; //Variable to hold the long latency resource id, this is used only in test parallel execution of DFC's

   111 	static void TestParallelExecutionCallback(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

   112 	TBool iCallbackReceived;

   113 	TBool iValidateCallbackReceived;

   114 	TPowerResourceCb iAsyncTestParallelCallback; //Callback object for handling long latency resources change state while deregistering non-dependency resource.

   115 	RArray <DDynamicPowerResource*> iDynamicArray; //Array to hold dynamic resources. This includes dynamic dependent resource

   116 #endif

   117 	};

   118 

   119 //class definition for multilevel single instantaneous positive resource

   120 class DLaterRegisterStaticResource : public DStaticPowerResource

   121 	{

   122 public:

   123 	DLaterRegisterStaticResource();

   124 	TInt DoRequest(TPowerRequest &req);

   125 	TInt GetInfo(TDes8* aInfo) const;

   126 private:

   127 	TInt iMinLevel;

   128 	TInt iMaxLevel;

   129 	TInt iCurrentLevel;

   130 	};

   131 

   132 //Constructors of the resource

   133 _LIT(KLaterRegisterStaticResource, "LaterRegisterStaticResource");

   134 DLaterRegisterStaticResource::DLaterRegisterStaticResource() : DStaticPowerResource(KLaterRegisterStaticResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

   135 	{

   136 	iFlags = KBinary;

   137 	}

   138 

   139 TInt DLaterRegisterStaticResource::DoRequest(TPowerRequest& req)

   140 	{

   141 	Kern::Printf("DLaterRegisterStaticResource::DoRequest\n");

   142 	if(req.ReqType() == TPowerRequest::EGet)

   143 		{

   144 		req.Level() = iCurrentLevel;

   145 		}

   146 	else if(req.ReqType() == TPowerRequest::EChange)

   147 		{

   148 		iCurrentLevel = req.Level();

   149 		}

   150 	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

   151 		{

   152 		req.Level() = iDefaultLevel;

   153 		iCurrentLevel = iDefaultLevel;

   154 		}

   155 	else

   156 		return KErrNotSupported;

   157 	return KErrNone;

   158 	}

   159 

   160 TInt DLaterRegisterStaticResource::GetInfo(TDes8* info) const

   161 	{

   162 	DStaticPowerResource::GetInfo((TDes8*)info);

   163 	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

   164 	buf1->iDefaultLevel = iDefaultLevel;

   165 	buf1->iMinLevel = iMinLevel;

   166 	buf1->iMaxLevel = iMaxLevel;

   167 	return KErrNone;

   168 	}

   169 

   170 //class definition for multilevel single instantaneous positive resource

   171 class DLaterRegisterStaticResource1 : public DStaticPowerResource

   172 	{

   173 public:

   174 	DLaterRegisterStaticResource1();

   175 	TInt DoRequest(TPowerRequest &req);

   176 	TInt GetInfo(TDes8* aInfo) const;

   177 private:

   178 	TInt iMinLevel;

   179 	TInt iMaxLevel;

   180 	TInt iCurrentLevel;

   181 	};

   182 

   183 //Constructors of the resource

   184 _LIT(KLaterRegisterStaticResource1, "LaterRegisterStaticResource1");

   185 DLaterRegisterStaticResource1::DLaterRegisterStaticResource1() : DStaticPowerResource(KLaterRegisterStaticResource1, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

   186 	{

   187 	iFlags = KBinary;

   188 	}

   189 

   190 TInt DLaterRegisterStaticResource1::DoRequest(TPowerRequest& req)

   191 	{

   192 	Kern::Printf("DLaterRegisterStaticResource1::DoRequest\n");

   193 	if(req.ReqType() == TPowerRequest::EGet)

   194 		{

   195 		req.Level() = iCurrentLevel;

   196 		}

   197 	else if(req.ReqType() == TPowerRequest::EChange)

   198 		{

   199 		iCurrentLevel = req.Level();

   200 		}

   201 	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

   202 		{

   203 		req.Level() = iDefaultLevel;

   204 		iCurrentLevel = iDefaultLevel;

   205 		}

   206 	else

   207 		return KErrNotSupported;

   208 	return KErrNone;

   209 	}

   210 

   211 TInt DLaterRegisterStaticResource1::GetInfo(TDes8* info) const

   212 	{

   213 	DStaticPowerResource::GetInfo((TDes8*)info);

   214 	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

   215 	buf1->iDefaultLevel = iDefaultLevel;

   216 	buf1->iMinLevel = iMinLevel;

   217 	buf1->iMaxLevel = iMaxLevel;

   218 	return KErrNone;

   219 	}

   220 

   221 //class definition for multilevel single instantaneous positive resource

   222 class DLaterRegisterStaticResource2 : public DStaticPowerResource

   223 	{

   224 public:

   225 	DLaterRegisterStaticResource2();

   226 	TInt DoRequest(TPowerRequest &req);

   227 	TInt GetInfo(TDes8* aInfo) const;

   228 private:

   229 	TInt iMinLevel;

   230 	TInt iMaxLevel;

   231 	TInt iCurrentLevel;

   232 	};

   233 

   234 //Constructors of the resource

   235 _LIT(KLaterRegisterStaticResource2, "LaterRegisterStaticResource2");

   236 DLaterRegisterStaticResource2::DLaterRegisterStaticResource2() : DStaticPowerResource(KLaterRegisterStaticResource2, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

   237 	{

   238 	iFlags = KBinary;

   239 	}

   240 

   241 TInt DLaterRegisterStaticResource2::DoRequest(TPowerRequest& req)

   242 	{

   243 	Kern::Printf("DLaterRegisterStaticResource2::DoRequest\n");

   244 	if(req.ReqType() == TPowerRequest::EGet)

   245 		{

   246 		req.Level() = iCurrentLevel;

   247 		}

   248 	else if(req.ReqType() == TPowerRequest::EChange)

   249 		{

   250 		iCurrentLevel = req.Level();

   251 		}

   252 	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

   253 		{

   254 		req.Level() = iDefaultLevel;

   255 		iCurrentLevel = iDefaultLevel;

   256 		}

   257 	else

   258 		return KErrNotSupported;

   259 	return KErrNone;

   260 	}

   261 

   262 TInt DLaterRegisterStaticResource2::GetInfo(TDes8* info) const

   263 	{

   264 	DStaticPowerResource::GetInfo((TDes8*)info);

   265 	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

   266 	buf1->iDefaultLevel = iDefaultLevel;

   267 	buf1->iMinLevel = iMinLevel;

   268 	buf1->iMaxLevel = iMaxLevel;

   269 	return KErrNone;

   270 	}

   271 

   272 TUint DTestResManLddFactory::iPostBootNotiCount = 0;

   273 SClientInfo DTestResManLddFactory::iClient = {NULL, 0};

   274 DTestResManLddFactory::DTestResManLddFactory()

   275 	{

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

   277 	iUnitsMask=0;

   278 	// Set version number for this device

   279 	iVersion=RTestResMan::VersionRequired();

   280 	}

   281 

   282 DTestResManLddFactory::~DTestResManLddFactory()

   283 	{

   284 	if(iDfcQ)

   285 	  iDfcQ->Destroy();

   286 	if(iStaticRes)

   287 		delete iStaticRes;

   288 	if(iStaticResArray[0])

   289 		delete iStaticResArray[0];

   290 	if(iStaticResArray[2])

   291 		delete iStaticResArray[2];

   292 	}

   293 

   294 /** Entry point for this driver */

   295 DECLARE_STANDARD_LDD()

   296 	{

   297 	DTestResManLddFactory* p = new DTestResManLddFactory;

   298 	if(!p)

   299 		return NULL;

   300 	TInt r = Kern::DynamicDfcQCreate(p->iDfcQ, KTestResManLddThreadPriority, KTestResManLddThread);

   301 	if(r != KErrNone)

   302 		{

   303 		Kern::Printf("Memory not allocated");

   304 		p->AsyncDelete();

   305 		return NULL;

   306 		}

   307 	//Register client with Resource Controller

   308 	TBuf8<32> ClientName(_L8("Client"));

   309 	p->iClient.pName = HBuf::New((const TDesC&)ClientName);

   310 	if(!p->iClient.pName)

   311 		{

   312 		p->iDfcQ->Destroy();

   313 		p->AsyncDelete();

   314 		return NULL;

   315 		}

   316 	//Allocating memory earlier so that during failure conditions can cleanup easily

   317 	p->iStaticRes = new DLaterRegisterStaticResource();

   318 	if(!p->iStaticRes)

   319 		{

   320 		delete p->iClient.pName;

   321 		p->iDfcQ->Destroy();

   322 		p->AsyncDelete();

   323 		return NULL;

   324 		}

   325 	p->iStaticResArray[0] = new DLaterRegisterStaticResource1();

   326 	if(!p->iStaticResArray[0])

   327 		{

   328 		delete p->iStaticRes;

   329 		delete p->iClient.pName;

   330 		p->iDfcQ->Destroy();

   331 		p->AsyncDelete();

   332 		return NULL;

   333 		}	

   334 	p->iStaticResArray[2] = new DLaterRegisterStaticResource2();

   335 	if(!p->iStaticResArray[2])

   336 		{

   337 		delete p->iStaticRes;

   338 		delete p->iStaticResArray[0];

   339 		delete p->iClient.pName;

   340 		p->iDfcQ->Destroy();

   341 		p->AsyncDelete();

   342 		return NULL;

   343 		}

   344 	r = PowerResourceManager::RegisterClient(DTestResManLddFactory::iClient.iClientId, (const TDesC&)*DTestResManLddFactory::iClient.pName);

   345 	if(r != KErrNone)

   346 		{

   347 		Kern::Printf("RegisterClient Failed\n");

   348 		Kern::Fault("PRM REGISTER CLIENT FAILED", __LINE__);

   349 		}

   350 	//Set postbootlevel for these resources.

   351 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 1, 0);

   352 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 6, 12);

   353 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 7, 1);

   354 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 12, 10);

   355 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 15, 0);

   356 #ifdef PRM_ENABLE_EXTENDED_VERSION

   357 	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 65537, -50);

   358 #endif

   359 	//Test the later registration of static resources.

   360 	r = DPowerResourceController::RegisterStaticResource(DTestResManLddFactory::iClient.iClientId, p->iStaticRes);

   361 	if(r != KErrNone)

   362 		Kern::Fault("PRM REGISTER STATIC RESOURCE FAILED", __LINE__);

   363 	DStaticPowerResource **resPtr = &p->iStaticResArray[0];

   364 	r = DPowerResourceController::RegisterArrayOfStaticResources(DTestResManLddFactory::iClient.iClientId, resPtr, 3);

   365 	if(r != KErrNone)

   366 		Kern::Fault("PRM REGISTER STATIC RESOURCE FAILED", __LINE__);

   367 	r = DSimulatedPowerResourceController::CompleteResourceControllerInitialisation();

   368 	if(r != KErrNone)

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

   370 	return p;

   371 	}

   372 

   373 void DTestResManLddFactory::SetPostBootLevelAndRequestNotification(TUint aClientId, TUint aResId, TInt aPostBootLevel)

   374 	{

   375 	DPowerResourceController::PostBootLevel(aResId, aPostBootLevel);

   376 	DPowerResourceNotification* iNoti = new DPowerResourceNotification(PostBootNotificationFunc, (TAny*)NULL, Kern::DfcQue0(), 3);

   377 	if(!iNoti)

   378 		{

   379 		Kern::Fault("PRM NOTI FAILED", __LINE__);

   380 		}

   381 	//Passing the address of the object so that it could be deleted in callback function

   382 	new (iNoti) DPowerResourceNotification(PostBootNotificationFunc, iNoti, Kern::DfcQue0(), 3);

   383 	TInt r = PowerResourceManager::RequestNotification(aClientId, aResId, *iNoti);

   384 	if(r != KErrNone)

   385 		Kern::Fault("PRM REQ NOTI FAILED", __LINE__);

   386 	}

   387 

   388 

   389 /** Second stage constuctor */

   390 TInt DTestResManLddFactory::Install()

   391 	{

   392    	return(SetName(&KTestPowerRCName));

   393 	}

   394 

   395 /** Device capabilities */

   396 void DTestResManLddFactory::GetCaps(TDes8& aDes)const

   397 	{

   398 	// Create a capabilities object

   399 	RTestResMan::TCaps caps;

   400 	caps.iVersion = iVersion;

   401 	// Write it back to user memory

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

   403 	}

   404 

   405 /** Create logical channel, only open of one channel is allowed */

   406 TInt DTestResManLddFactory::Create(DLogicalChannelBase*& aChannel)

   407 	{

   408    	if (iOpenChannels != 0) //A Channel is already open

   409 		return KErrInUse;

   410 	//Deregister the client registered in ldd init. 

   411 	TInt r = PowerResourceManager::DeRegisterClient(DTestResManLddFactory::iClient.iClientId);

   412 	if(r != KErrNone)

   413 		Kern::Fault("PRM CLIENT DEREGISTER FAILED", __LINE__);

   414 	delete DTestResManLddFactory::iClient.pName;

   415 	DTestResManLddFactory::iClient.pName = NULL;

   416 	DTestResManLddFactory::iClient.iClientId = 0;

   417 	aChannel = new DTestResManLdd;

   418 	if(!aChannel)

   419 		return KErrNoMemory;

   420 	return KErrNone;

   421 	}

   422 

   423 /** Constructor */

   424 DTestResManLdd::DTestResManLdd(): iAsyncResourceCallback(CallbackFunc, this, 3)

   425 #ifdef PRM_ENABLE_EXTENDED_VERSION

   426 				, iAsyncTestParallelCallback(TestParallelExecutionCallback, this, 3)

   427 #endif

   428 	{

   429 	iCondList = NULL;

   430 	iUnCondList = NULL;

   431 	iCallbackCancel = EFalse;

   432 	iClientId = 0;

   433 	iResourceId = 0;

   434 	iStatePtr = NULL;

   435 	iLevelOwnerIdPtr = NULL;

   436 	for(TUint c = 0; c < MAX_CLIENTS; c++)

   437 		{

   438 		clientInfo[c].iClientId = 0;

   439 		clientInfo[c].pName = NULL;

   440 		}

   441 	iClientThreadPtr=&Kern::CurrentThread();

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

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

   444 	}

   445 

   446 /** Destructor */

   447 DTestResManLdd::~DTestResManLdd()

   448 	{

   449 	if(pBuf) //Buffer created for storing idle resource information

   450 		delete pBuf;

   451 #ifdef PRM_ENABLE_EXTENDED_VERSION

   452 	for(TInt c = 0; c < iDynamicArray.Count(); c++)

   453 		{

   454 		delete iDynamicArray[c]; //Delete the dynamic array. This includes dynamic dependent resource.

   455 		}

   456 	iDynamicArray.Close();

   457 #endif

   458 	// Close our reference on the client thread

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

   460 	}

   461 

   462 /** Second stage constructor. */

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

   464 	{

   465    	// Check version

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

   467 		return KErrNotSupported;

   468 	SetDfcQ(((DTestResManLddFactory*)iDevice)->iDfcQ);

   469 	iAsyncResourceCallback.SetDfcQ(iDfcQ);

   470 #ifdef PRM_ENABLE_EXTENDED_VERSION

   471 	iAsyncTestParallelCallback.SetDfcQ(iDfcQ);

   472 #endif

   473  	iMsgQ.Receive();

   474 	return KErrNone;

   475 	}

   476 

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

   478 void DTestResManLdd::HandleMsg(TMessageBase* aMsg)

   479 	{

   480 	TThreadMessage& m=*(TThreadMessage*)aMsg;

   481 	TInt id=m.iValue;

   482 

   483 	if (id==(TInt)ECloseMsg)

   484 		{

   485 		// Channel close.

   486 		m.Complete(KErrNone,EFalse);

   487 		return;

   488 		}

   489 	else if (id==KMaxTInt)

   490 		{

   491 		// DoCancel

   492 		m.Complete(KErrNone,ETrue);

   493 		return;

   494 		}

   495 	else if (id<0)

   496 		{

   497 		// DoRequest

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

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

   500 		if (r!=KErrNone)

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

   502 		m.Complete(KErrNone,ETrue);

   503 		}

   504 	else

   505 		{

   506 		// DoControl

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

   508 		m.Complete(r,ETrue);

   509 		}

   510 	}

   511 

   512 

   513 /**

   514   Process synchronous 'control' requests

   515 */

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

   517 	{

   518 	TInt r = KErrNone;

   519 	TParameterListInfo ptr = {0, 0, 0, 0, 0};

   520 	//Copy parameter structure from user space.

   521 	if((aFunction != RTestResMan::EDeRegisterClient) && (aFunction != RTestResMan::ERequestNotificationUncond) && 

   522 		   (aFunction != RTestResMan::ERegisterForIdleResourcesInfo) && (aFunction != RTestResMan::EGetIdleResourcesInfo) 

   523 		   && (aFunction != RTestResMan::EDeRegisterClientLevelFromResource) && (aFunction != RTestResMan::ECheckPostBootLevelNotifications)

   524 		   && (aFunction != RTestResMan::EGetControllerVersion)

   525 #ifdef PRM_ENABLE_EXTENDED_VERSION

   526 		   && (aFunction != RTestResMan::ERegisterDynamicResource))

   527 #else

   528 		   )

   529 #endif

   530 		{

   531 		r = Kern::ThreadRawRead(iClientThreadPtr, (TParameterListInfo*)a1, &ptr, sizeof(TParameterListInfo));

   532 		if(r != KErrNone)

   533 			return r;

   534 		}

   535 	switch(aFunction)

   536 		{

   537 		case RTestResMan::ERegisterClient:

   538 			{

   539 			TBuf8<256> aName;

   540 			TUint c;

   541 			//Copy name from user address space

   542 			r = Kern::ThreadDesRead(iClientThreadPtr, (const TDesC*)ptr.iPtr2, (TDes8&)aName, 0);

   543 			if(r != KErrNone)

   544 				{

   545 				Kern::Printf("RTestResMan::ERegisterClient ThreadDesRead failed with %d", r);

   546 				break;

   547 				}

   548 			for(c = 0; c < MAX_CLIENTS; c++)

   549 				{

   550 				if(clientInfo[c].pName == NULL)

   551 					break;

   552 				if(!clientInfo[c].pName->Compare(aName))

   553 					return KErrAlreadyExists;

   554 				}

   555 			if(c == MAX_CLIENTS)

   556 				return KErrOverflow;

   557 			clientInfo[c].pName = HBuf::New((const TDesC8&)aName);

   558 			if(!clientInfo[c].pName)

   559 				return KErrNoMemory;

   560 			r = PowerResourceManager::RegisterClient(clientInfo[c].iClientId, (const TDesC&)*clientInfo[c].pName, (TOwnerType)(TInt)ptr.iPtr3);

   561 			if(r != KErrNone)

   562 				{

   563 				delete clientInfo[c].pName;

   564 				clientInfo[c].pName = NULL;

   565 				clientInfo[c].iClientId = 0;

   566 				}

   567 			if(r == KErrNone)

   568 				{

   569 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr1, &clientInfo[c].iClientId, sizeof(TUint));

   570 				if(r != KErrNone)

   571 					Kern::Printf("RTestResMan::ERegisterClient ThreadRawWrite failed with %d", r);

   572 				}

   573 			break;

   574 			}

   575 		case RTestResMan::EDeRegisterClient: //Deregister client from RM

   576 			{

   577 			//Cancel all notification pending for this client

   578 			SNotificationList *pL;

   579 			SNotificationList* pN = iCondList;

   580 			while(pN != NULL)

   581 				{

   582 				if(pN->iClientId == (TUint)a1)

   583 					{

   584 					PowerResourceManager::CancelNotification(pN->iClientId, pN->iResourceId, *pN->iNoti);

   585 					pL = pN;

   586 					pN = pN->iNext;

   587 					LIST_REMOVE(iCondList, pL, iNext, SNotificationList);

   588 					delete pL->iNoti;

   589 					delete pL;

   590 					}

   591 				else

   592 					pN = pN->iNext;

   593 				}

   594 			pN = iUnCondList;

   595 			while(pN != NULL)

   596 				{

   597 				if(pN->iClientId == (TUint)a1)

   598 					{

   599 					PowerResourceManager::CancelNotification(pN->iClientId, pN->iResourceId, *pN->iNoti);

   600 					pL = pN;

   601 					pN = pN->iNext;

   602 					LIST_REMOVE(iUnCondList, pL, iNext, SNotificationList);

   603 					delete pL->iNoti;

   604 					delete pL;

   605 					}

   606 				else

   607 				   pN = pN->iNext;

   608 				}

   609 			iClientId = -1;

   610 			r = PowerResourceManager::DeRegisterClient((TUint)a1);

   611 			if(r != KErrNone)

   612 				break;

   613 			r = KErrNotFound;

   614 			for(TUint c = 0; c < MAX_CLIENTS; c++)

   615 				{

   616 				if(clientInfo[c].iClientId == (TUint)a1)

   617 					{

   618 					delete clientInfo[c].pName;

   619 					clientInfo[c].pName = 0;

   620 					clientInfo[c].iClientId = 0;

   621 					r = KErrNone;

   622 					break;

   623 					}

   624 				}

   625 

   626 			break;

   627 			}

   628 		case RTestResMan::EGetClientName: //Get Client Name

   629 			{

   630 			TBuf8<32> aName; 

   631 			r = PowerResourceManager::GetClientName((TUint)ptr.iClientId, (TUint)ptr.iPtr1, (TDes &)aName);

   632 			if(r== KErrNone)

   633 				{

   634 				r = Kern::ThreadDesWrite(iClientThreadPtr, ptr.iPtr2, (const TDesC8&)aName, 0);

   635 				if(r != KErrNone)

   636 					Kern::Printf("RTestResMan::EGetClientName ThreadDesWrite failed with %d", r);

   637 				}

   638 			break;

   639 			}

   640 		case RTestResMan::EGetClientId: //Get Client Id

   641 			{

   642 			TBuf8<256> aName;

   643 			TUint aClientId; 

   644 			r = Kern::ThreadDesRead(iClientThreadPtr, (const TDesC*)ptr.iPtr1, (TDes8&)aName, 0,KChunkShiftBy0);

   645 			if(r != KErrNone)

   646 				{

   647 				Kern::Printf("RTestResMan::EGetClientId ThreadDesRead failed with %d", r);

   648 				break;

   649 				}

   650 			r = PowerResourceManager::GetClientId(ptr.iClientId, (TDesC&)aName, aClientId);

   651 			if(r == KErrNone)

   652 				{

   653 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &aClientId, sizeof(TUint));

   654 				if(r != KErrNone)

   655 					Kern::Printf("RTestResMan::EGetClientId ThreadRawWrite failed with %d", r);

   656 				}

   657 			break;

   658 			}

   659 		case RTestResMan::EGetResourceId: //Get Resource Id

   660 			{

   661 			TBuf8<256> aName; 

   662 			TUint aResourceId;

   663 			r = Kern::ThreadDesRead(iClientThreadPtr, (const TDesC*)ptr.iPtr1, (TDes8&)aName, 0,KChunkShiftBy0);

   664 			if(r != KErrNone)

   665 				{

   666 				Kern::Printf("RTestResMan::EGetResourceId ThreadDesRead failed with %d", r);

   667 				break;

   668 				}

   669 			r = PowerResourceManager::GetResourceId(ptr.iClientId, (TDesC&)aName, aResourceId);

   670 			if(r == KErrNone)

   671 				{

   672 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &aResourceId, sizeof(TUint));

   673 				if(r != KErrNone)

   674 					Kern::Printf("RTestResMan::EGetResourceId ThreadRawWrite failed with %d", r);

   675 				}

   676 			break;

   677 			}

   678 		case RTestResMan::EGetResourceInfo: //Get resource information

   679 			{

   680 			NKern::ThreadEnterCS();

   681 			HBuf *info = HBuf::New(sizeof(TPowerResourceInfoV01));

   682 			NKern::ThreadLeaveCS();

   683 			r = PowerResourceManager::GetResourceInfo(ptr.iClientId, (TUint)ptr.iPtr1, (TAny*)info);

   684 			if(r == KErrNone)

   685 				{

   686 				r = Kern::ThreadDesWrite(iClientThreadPtr, ptr.iPtr2, (const TDesC8&)*info, 0);

   687 				if(r != KErrNone)

   688 					Kern::Printf("RTestResMan::EGetResourceInfo ThreadRawWrite failed with %d", r);

   689 				}

   690 			Kern::Free(info);

   691 			break;

   692 			} 

   693 		case RTestResMan::EGetNumResourcesInUseByClient: 

   694 			{

   695 			TUint numResource;

   696 			r = PowerResourceManager::GetNumResourcesInUseByClient(ptr.iClientId, (TUint)ptr.iPtr1, numResource);

   697 			if(r == KErrNone)

   698 				{

   699 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &numResource, sizeof(TUint));

   700 				if(r != KErrNone)

   701 					Kern::Printf("RTestResMan::EGetNumResourcesInUseByClient ThreadRawWrite failed with %d", r);

   702 				}

   703 			 break;

   704 			}

   705 		case RTestResMan::EGetInfoOnResourcesInUseByClient:

   706 			{

   707 			TUint numResource;

   708 			HBuf* info = NULL;

   709 			r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr2, &numResource, sizeof(TUint));

   710 			if(r != KErrNone)

   711 				{

   712 				Kern::Printf("RTestResMan::GetInfoOnResourceInUseByClient ThreadRawRead failed with %d", r);

   713 				break;

   714 				}

   715 			if(ptr.iPtr3 != NULL)

   716 				{

   717 				NKern::ThreadEnterCS();

   718 				info = HBuf::New(numResource * sizeof(TPowerResourceInfoV01));

   719 				NKern::ThreadLeaveCS();

   720 				}

   721 			r = PowerResourceManager::GetInfoOnResourcesInUseByClient(ptr.iClientId, (TUint)ptr.iPtr1, numResource, (TAny*)info);

   722 			if(r == KErrNone)

   723 				{

   724 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &numResource, sizeof(TUint));

   725 				if(r !=KErrNone)

   726 					{

   727 					Kern::Printf("RTestResMan::GetInfoOnResourceInUseByClient ThreadRawWrite failed with %d", r);

   728 					Kern::Free(info);

   729 					break;

   730 					}

   731 				if(ptr.iPtr3)

   732 					r = Kern::ThreadDesWrite(iClientThreadPtr, ptr.iPtr3, (const TDesC8&)*info, 0);

   733 				}

   734 			Kern::Free(info);

   735 			break;

   736 			}

   737 		case RTestResMan::EGetNumClientsUsingResource:

   738 			{

   739 			TUint numClient;

   740 			r = PowerResourceManager::GetNumClientsUsingResource(ptr.iClientId, (TUint)ptr.iPtr1, numClient);

   741 			if(r == KErrNone)

   742 				{

   743 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &numClient, sizeof(TUint));

   744 				if(r != KErrNone)

   745 					Kern::Printf("RTestResMan::EGetNumResourcesInUseByClient ThreadRawWrite failed with %d", r);

   746 				}

   747 			break;

   748 			}

   749 		case RTestResMan::EGetInfoOnClientsUsingResource:

   750 			{

   751 			TUint numClient;

   752 			HBuf* info = NULL;

   753 			r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr2, &numClient, sizeof(TUint));

   754 			if(r != KErrNone)

   755 				{

   756 				Kern::Printf("RTestResMan::GetInfoOnResourceInUseByClient ThreadRawRead failed with %d", r);

   757 				break;

   758 				}

   759 			if(ptr.iPtr3 != NULL)

   760 				{

   761 				NKern::ThreadEnterCS();

   762 				info = HBuf::New(numClient * sizeof(TPowerClientInfoV01));

   763 				NKern::ThreadLeaveCS();

   764 				}

   765 			r = PowerResourceManager::GetInfoOnClientsUsingResource(ptr.iClientId, (TUint)ptr.iPtr1, numClient, (TAny*)info);

   766 			if(r == KErrNone)

   767 				{

   768 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, &numClient, sizeof(TUint));

   769 				if(r !=KErrNone)

   770 					{

   771 					Kern::Printf("RTestResMan::GetInfoOnResourceInUseByClient ThreadRawWrite failed with %d", r);

   772 					Kern::Free(info);

   773 					break;

   774 					}

   775 				 if(ptr.iPtr3)

   776 					r = Kern::ThreadDesWrite(iClientThreadPtr, ptr.iPtr3, (const TDesC8&)*info, 0);

   777 				}

   778 			Kern::Free(info);

   779 			break;

   780 			}

   781 		case RTestResMan::EAllocReserve:

   782 			{

   783 			r = PowerResourceManager::AllocReserve(ptr.iClientId, (TUint8)(TUint)ptr.iPtr1, (TUint8)(TUint)ptr.iPtr2);

   784 			break;

   785 			}

   786 		case RTestResMan::EChangeResourceStateSync:

   787 			{

   788 			SNotificationList* pN; 

   789 			//Zero the conditional notification count for the resource id.

   790 			for(pN=iCondList; pN != NULL; pN=pN->iNext)

   791 				{

   792 				if(pN->iResourceId == (TUint)ptr.iPtr1)

   793 					{

   794 					pN->iCount = 0;

   795 					break;

   796 					}

   797 				}

   798 			//Zero the unconditional notification count for the resource id.

   799 			for(pN=iUnCondList; pN != NULL; pN=pN->iNext)

   800 				{

   801 				if(pN->iResourceId == (TUint)ptr.iPtr1)

   802 					{

   803 					pN->iCount = 0;

   804 					break;

   805 					}

   806 				}

   807 			iClientId = ptr.iClientId;

   808 			iResourceId = (TUint)ptr.iPtr1;

   809 			r = PowerResourceManager::ChangeResourceState(ptr.iClientId, (TUint)ptr.iPtr1, (TInt)ptr.iPtr2);

   810 			break;

   811 			}

   812 		case RTestResMan::EGetResourceStateSync:

   813 			{

   814 			TInt newState, levelOwnerId;

   815 			r = PowerResourceManager::GetResourceState(ptr.iClientId, (TUint)ptr.iPtr1, (TBool)ptr.iPtr2, newState, levelOwnerId);

   816 			if(r == KErrNone)

   817 				{

   818 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr3, (TAny*)&newState, sizeof(TInt));

   819 				if(r != KErrNone)

   820 					{

   821 					Kern::Printf("RTestResMan::GetResourceStateSync ThreadRawWrite failed with %d", r);

   822 					break;

   823 					}

   824 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr4, (TAny*)&levelOwnerId, sizeof(TInt));

   825 				if(r != KErrNone)

   826 					Kern::Printf("RTestResMan::GetResourceStateSync ThreadRawWrite failed with %d", r);

   827 				}

   828 			break;

   829 			}

   830 		case RTestResMan::ERequestNotificationUncond:

   831 			{

   832 			SNotificationList *notiList;

   833 			notiList = new SNotificationList; //Create new notification list

   834 			if(!notiList)

   835 				{

   836 				r = KErrNoMemory;

   837 				break;

   838 				}

   839 			//Create notification object to pass to RM

   840 			notiList->iNoti = new DPowerResourceNotification(UnCondNotificationFunc, this, ((DTestResManLddFactory*)iDevice)->iDfcQ, 3);

   841 			if(!notiList->iNoti)

   842 				{

   843 				delete notiList;

   844 				r = KErrNoMemory;

   845 				break;

   846 				}

   847 			notiList->iClientId = (TUint)a1;

   848 			notiList->iResourceId = (TUint)a2;

   849 			notiList->iCount = 0;

   850 			LIST_PUSH(iUnCondList, notiList, iNext); //Add to unconditional list.							 

   851 			r = PowerResourceManager::RequestNotification((TUint)a1, (TUint)a2, *notiList->iNoti);

   852 			break;

   853 			}

   854 		case RTestResMan::ERequestNotificationCond:

   855 			{

   856 			SNotificationList *notiList;

   857 			notiList = new SNotificationList; // Create new notification list

   858 			if(!notiList)

   859 				{

   860 				r = KErrNoMemory;

   861 				break;

   862 				}

   863 			//Create notification object to pass to RM

   864 			notiList->iNoti = new DPowerResourceNotification(CondNotificationFunc, this, ((DTestResManLddFactory*)iDevice)->iDfcQ, 3);

   865 			if(!notiList->iNoti)

   866 				{

   867 				delete notiList;

   868 				r = KErrNoMemory;

   869 				break;

   870 				}

   871 			notiList->iClientId = ptr.iClientId;

   872 			notiList->iResourceId = (TUint)ptr.iPtr1;

   873 			notiList->iCount = 0;

   874 			LIST_PUSH(iCondList, notiList, iNext); //Add to conditional list.

   875 			r = PowerResourceManager::RequestNotification((TUint)ptr.iClientId, (TUint)ptr.iPtr1, *notiList->iNoti, (TInt)ptr.iPtr2, (TBool)ptr.iPtr3);

   876 			break;

   877 			}

   878 		case RTestResMan::EDeRegisterClientLevelFromResource:	

   879 			{

   880 				r = PowerResourceManager::DeRegisterClientLevelFromResource((TUint)a1, (TUint)a2);

   881 				break;

   882 			} 

   883 		case RTestResMan::ECancelNotification:

   884 			{

   885 			r = KErrNotFound;

   886 			if(ptr.iPtr2) //Check for notification in conditional list if it is true.

   887 				{ 

   888 				for(SNotificationList* pN=iCondList; pN != NULL; pN=pN->iNext)

   889 					{

   890 					if((pN->iClientId == ptr.iClientId) && (pN->iResourceId == (TUint)ptr.iPtr1))

   891 						{

   892 						r = PowerResourceManager::CancelNotification(pN->iClientId, pN->iResourceId, *pN->iNoti);

   893 						LIST_REMOVE(iCondList, pN, iNext, SNotificationList);

   894 						delete pN->iNoti;

   895 						delete pN;

   896 						break;

   897 						}

   898 					}

   899 				}

   900 			else //Check for notification in unconditional list.

   901 				{

   902 				for(SNotificationList* pN=iUnCondList; pN != NULL; pN=pN->iNext)

   903 					{

   904 					if((pN->iClientId == ptr.iClientId) && (pN->iResourceId == (TUint)ptr.iPtr1))

   905 						{

   906 						r = PowerResourceManager::CancelNotification(pN->iClientId, pN->iResourceId, *pN->iNoti);

   907 						LIST_REMOVE(iUnCondList, pN, iNext, SNotificationList);

   908 						delete pN->iNoti;

   909 						delete pN;

   910 						break;

   911 						}

   912 					}

   913 				}

   914 			break;

   915 			}

   916 		case RTestResMan::ECheckNotifications:

   917 			{

   918 			NKern::Sleep(NKern::TimerTicks(300)); //This is required as sometimes check is done before callback is called.

   919 			TUint countCond = 0, countUncond = 0;

   920 			SNotificationList* pN; 

   921 			//Get the conditional notification callback functions called for the resource id.

   922 			for(pN=iCondList; pN != NULL; pN=pN->iNext)

   923 				{

   924 				if(pN->iResourceId == (TUint)ptr.iPtr1)

   925 					{

   926 					countCond = pN->iCount;

   927 					pN->iCount = 0;

   928 					break;

   929 					}

   930 				}

   931 			//Get the unconditional notification callback functions called for the resource id.

   932 			for(pN=iUnCondList; pN != NULL; pN=pN->iNext)

   933 				{

   934 				if(pN->iResourceId == (TUint)ptr.iPtr1)

   935 					{

   936 					countUncond = pN->iCount;

   937 					pN->iCount = 0;

   938 					break;

   939 					}

   940 				}

   941 			//If the notifications count is not as expected return error.

   942 			if((countCond != (TUint)ptr.iPtr3) || (countUncond != (TUint)ptr.iPtr2))

   943 				r = KErrUnderflow;

   944 			break;

   945 			}

   946 		case RTestResMan::ERegisterForIdleResourcesInfo:

   947 			{	

   948 			if(pBuf)

   949 				{

   950 				r = KErrAlreadyExists;

   951 				break;

   952 				}

   953 			NKern::ThreadEnterCS();

   954 			pBuf = HBuf::New((TUint)a2 * sizeof(SIdleResourceInfo)); //Allocate buffer for requested resources

   955 			NKern::ThreadLeaveCS();

   956 			if(!pBuf)

   957 				return KErrNoMemory;

   958 			SIdleResourceInfo* pI = (SIdleResourceInfo*)pBuf->Ptr();

   959 			for(TUint c = 0; c < (TUint)a2; c++)

   960 				pI[c].iResourceId = c+1; //Update resource id

   961 			//Below function calls RegisterForResourceIdle resource controller virtual function, 

   962 			//This is for testing purposes only.

   963 

   964 			r =DSimulatedPowerResourceController::CaptureIdleResourcesInfo((TUint)a1, (TUint)a2, (TPtr*)pI);

   965 			if( r == KErrInUse)

   966 			   delete pBuf;

   967 			break;

   968 			}

   969 		case RTestResMan::EGetIdleResourcesInfo:

   970 			{

   971 			//Pass the buffer for comparision

   972 			if(!pBuf)

   973 				{

   974 				r = KErrNotFound;

   975 				break;

   976 				}

   977 			pBuf->SetLength(sizeof(SIdleResourceInfo) * (TUint)a1);

   978 			r = Kern::ThreadDesWrite(iClientThreadPtr, a2, (const TDesC8&)*pBuf, 0);

   979 			break;

   980 			}

   981 		case RTestResMan::ECheckPostBootLevelNotifications:

   982 			{

   983 				if(DTestResManLddFactory::iPostBootNotiCount != EXPECTED_POST_NOTI_COUNT)

   984 				{

   985 				r = KErrUnderflow;

   986 				break;

   987 				}

   988 			r = KErrNone;

   989 			break;

   990 			}

   991 		case RTestResMan::EGetControllerVersion:

   992 			{

   993 			TUint Version;

   994 			r = PowerResourceManager::GetResourceControllerVersion((TUint)a1, Version);

   995 			if(r == KErrNone)

   996 				{

   997 				r = Kern::ThreadRawWrite(iClientThreadPtr, a2, &Version, sizeof(TUint));

   998 				if(r != KErrNone)

   999 					Kern::Printf("RTestResMan::EGetControllerVersion ThreadRawWrite failed with %d", r);

  1000 				}

  1001 			break;

  1002 			}

  1003 #ifdef PRM_ENABLE_EXTENDED_VERSION

  1004 		case RTestResMan::ERegisterDynamicResource:

  1005 			{

  1006 			TUint resId;

  1007 			r = Kern::ThreadRawRead(iClientThreadPtr, a2, (TAny*)&resId, sizeof(TUint));

  1008 			if(r != KErrNone)

  1009 				{

  1010 				Kern::Printf("RTestResMan::RegisterDynamicResource ThreadRawRead failed with %d", r);

  1011 				break;

  1012 				}			

  1013 			DDynamicPowerResource* pDR = NULL;

  1014 			switch(resId) //Create the dynamic resource

  1015 				{

  1016 				case 1:

  1017 					pDR = new (DBIGISSPDynamicResource);

  1018 					break;

  1019 				case 2:

  1020 					pDR = new (DMLIGLSSHNDynamicResource);

  1021 					break;

  1022 				case 3: 

  1023 					pDR = new (DBLGLSSHNDynamicResource);

  1024 					break;

  1025 				case 4:

  1026 					pDR = new (DMLLGLSSHPDynamicResource);

  1027 					break;

  1028 				case 5:

  1029 					pDR = (DDynamicPowerResource*) new (DDynamicResourceD01);

  1030 					break;

  1031 				case 6:

  1032 					pDR = (DDynamicPowerResource*) new (DDynamicResourceD02);

  1033 					break;

  1034 				case 7:

  1035 					pDR = (DDynamicPowerResource*) new (DDynamicResourceD03);

  1036 					break;

  1037 				case 8:

  1038 					pDR = (DDynamicPowerResource*) new (DDynamicResourceD04);

  1039 					break;

  1040 				}

  1041 			if(!pDR)

  1042 				return KErrNoMemory;

  1043 			iDynamicArray.Append(pDR);

  1044 			r = PowerResourceManager::RegisterDynamicResource((TUint)a1, pDR, resId);

  1045 			if(r == KErrNone)

  1046 				{

  1047 				r = Kern::ThreadRawWrite(iClientThreadPtr, a2, (TAny*)&resId, sizeof(TUint));

  1048 				if(r != KErrNone)

  1049 					Kern::Printf("RTestResMan::RegisterDynamicResource ThreadRawWrite failed with %d", r);

  1050 				}

  1051 			break;

  1052 			}

  1053 		case RTestResMan::EDeRegisterDynamicResource: //Deregister dynamic resource

  1054 			{

  1055 			if(ptr.iPtr2)

  1056 				{

  1057 				TInt level;

  1058 				r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr2, &level, sizeof(TInt));

  1059 				if(r != KErrNone)

  1060 					{

  1061 					Kern::Printf("RTestResMan::DeRegisterDynamicResource ThreadRawRead failed with %d", r);

  1062 					break;

  1063 					}	

  1064 				r = PowerResourceManager::DeRegisterDynamicResource(ptr.iClientId, (TUint)ptr.iPtr1, &level);

  1065 				}

  1066 			else

  1067 				r = PowerResourceManager::DeRegisterDynamicResource(ptr.iClientId, (TUint)ptr.iPtr1, NULL);

  1068 			break;

  1069 			}

  1070 		case RTestResMan::ERegisterResourceDependency: //Register resource dependency

  1071 			{

  1072 			SResourceDependencyInfo info1, info2;

  1073 			r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr1, &info1, sizeof(SResourceDependencyInfo));

  1074 			if(r != KErrNone)

  1075 				{

  1076 				Kern::Printf("RTestResMan::RegisterResourceDependency ThreadRawRead failed with %d", r);

  1077 				break;

  1078 				}

  1079 			r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr2, &info2, sizeof(SResourceDependencyInfo));

  1080 			if(r != KErrNone)

  1081 				{

  1082 				Kern::Printf("RTestResMan::RegisterResourceDependency ThreadRawRead failed with %d", r);

  1083 				break;

  1084 				}

  1085 			r = PowerResourceManager::RegisterResourceDependency(ptr.iClientId, &info1, &info2);

  1086 			break;

  1087 			}

  1088 		case RTestResMan::EDeRegisterResourceDependency: //Deregister resource dependency

  1089 			{

  1090 			r = PowerResourceManager::DeRegisterResourceDependency(ptr.iClientId, (TUint)ptr.iPtr1, (TUint)ptr.iPtr2);

  1091 			break;

  1092 			}

  1093 		case RTestResMan::EGetNumDependentsForResource:

  1094 			{

  1095 			TUint numDepResources;

  1096 			r = PowerResourceManager::GetNumDependentsForResource(ptr.iClientId, (TUint)ptr.iPtr1, numDepResources);

  1097 			if(r == KErrNone)

  1098 				{

  1099 				r = Kern::ThreadRawWrite(iClientThreadPtr, ptr.iPtr2, (TAny*)&numDepResources, sizeof(TUint));

  1100 				if(r != KErrNone)

  1101 					Kern::Printf("RTestResMan::RegisterDynamicResource ThreadRawWrite failed with %d", r);

  1102 				}

  1103 			break;

  1104 			}

  1105 		case RTestResMan::EGetDependentsIdForResource:

  1106 			{

  1107 			TUint numDepResources;

  1108 			HBuf* sResDepInfo = NULL;

  1109 			r = Kern::ThreadRawRead(iClientThreadPtr, ptr.iPtr3, (TAny*)&numDepResources, sizeof(TUint));

  1110 			if(r != KErrNone)

  1111 				{

  1112 				Kern::Printf("RTestResMan::GetDependentsIdForResource ThreadRawRead failed with %d", r);

  1113 				break;

  1114 				}

  1115 			if(ptr.iPtr2 != NULL)

  1116 				{

  1117 				NKern::ThreadEnterCS();

  1118 				sResDepInfo = HBuf::New(numDepResources * sizeof(SResourceDependencyInfo));

  1119 				NKern::ThreadLeaveCS();

  1120 				if(!sResDepInfo)

  1121 					return KErrNoMemory;

  1122 				}

  1123 			

  1124 			r = PowerResourceManager::GetDependentsIdForResource(ptr.iClientId, (TUint)ptr.iPtr1, (TAny*)sResDepInfo, numDepResources);

  1125 			if(r == KErrNone)

  1126 				{

  1127 				if(ptr.iPtr2)

  1128 					r = Kern::ThreadDesWrite(iClientThreadPtr, ptr.iPtr2, (const TDesC8&)*sResDepInfo, 0);

  1129 				if(r != KErrNone)

  1130 					{

  1131 					Kern::Printf("RTestResMan::GetDepedentsIdForResource ThreadDesWrite failed with %d", r);

  1132 					Kern::Free(sResDepInfo);

  1133 					break;

  1134 					}