// Copyright (c) 2007-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\include\drivers\resource_extend.h

 // 

 // WARNING: This file contains some APIs which are internal and are subject

 //          to change without notice. Such APIs should therefore not be used

 //          outside the Kernel and Hardware Services package.

 //

 #ifndef __RESOURCE_EXTEND_H__

 #define __RESOURCE_EXTEND_H__

 #include <drivers/resource.h>

 #define ADD_DEPENDENCY_NODE(aNode, aDependencyList)																	\

 	{																												\

 	SNode* pDL = aDependencyList;																					\

 	SNode* prev = NULL;																								\

 	if(pDL == NULL)																									\

 		{																											\

 		aDependencyList = aNode;																					\

 		aNode->iNext = NULL;																						\

 		}																											\

 	else																											\

 		{																											\

 		while(pDL != NULL)																							\

 			{																										\

 			if(aNode->iPriority == pDL->iPriority)																	\

 				return KErrAlreadyExists;																			\

 			if(aNode->iPriority < pDL->iPriority)																	\

 				{																									\

 				if(prev == NULL) /*Add it to the head	*/															\

 					{																								\

 					aDependencyList = aNode;																		\

 					aNode->iNext = pDL;																				\

 					break;																							\

 					}																								\

 				prev->iNext = aNode;																				\

 				aNode->iNext = pDL;																					\

 				break;																								\

 				}																									\

 			if(pDL->iNext == NULL) /* Add it to the end	*/															\

 				{																									\

 				pDL->iNext = aNode;																					\

 				aNode->iNext = NULL;																				\

 				break;																								\

 				}																									\

 			prev = pDL;																								\

 			pDL = pDL->iNext;																						\

 			}																										\

 		}																											\

 	}

 //Check whether the priority already exists

 #define CHECK_IF_PRIORITY_ALREADY_EXISTS(aDependencyList, aPriority)			\

 	{																			\

 	for(SNode* node = aDependencyList; node != NULL; node = node->iNext)		\

 		{																		\

 		if(node->iPriority == aPriority)										\

 			return KErrAlreadyExists;											\

 		}																		\

 	}

 static const TUint KIdMaskStaticWithDependencies	= 0x00010000;

 static const TUint KIdMaskDynamic					= 0x00020000;

 static const TUint KIdMaskDynamicWithDependencies	= 0x00030000;

 static const TUint KIdMaskResourceWithDependencies = 0x00010000;

 static const TInt KDynamicResourceDeRegistering = -2; 

 struct SNode;

 struct SPowerResourceClientLevel;

 //Various stages of resource dependency state change operation.

 enum TPropagation

 	{

 	EChangeStart,

 	ECheckChangeAllowed,

 	ERequestStateChange,

 	EIssueNotifications

 	};

 //Return value of translate dependency state function. This is implemented by PSL for each resource.

 enum TChangePropagationStatus {EChange, ENoChange, EChangeNotAccepted};

 /**

 @publishedPartner

 @prototype 9.5

 class to represent dynamic resources

 */

 class DDynamicPowerResource : public DStaticPowerResource

 	{

 public:

 	IMPORT_C DDynamicPowerResource(const TDesC8& aName, TInt aDefaultLevel);

 	IMPORT_C ~DDynamicPowerResource();

 public:

 	TBool InUse(); //Used by RC on deregistration to see if another client is having requirement on this resource

 	inline void Lock() {++iCount;} //Resource is locked whenever operation is scheduled in RC thread. 

 	inline void UnLock() {--iCount;}

 	inline TUint LockCount() { return iCount;}

 protected:

 	TUint iCount;

 	TUint iOwnerId; //Stores the ID of the client that registers the resource

 	friend class DPowerResourceController;

 	};

 /**

 @publishedPartner

 @prototype 9.5

 */

 typedef TBool (*TDependencyCustomFunction) (TInt& /*aClientId*/,

                                             const TDesC8& /*aClientName*/,

                                             TUint /*aResourceId*/,

                                             TCustomOperation /*aCustomOperation*/,

                                             TInt& /*aLevel*/,

                                             TAny* /*aLevelList*/,

                                             TAny* /*aResourceLevelList */,

                                             TAny* /*aReserved*/); // For future use

 /**

 @publishedPartner

 @prototype 9.5

 class to represent static resource with dependency

 */

 class DStaticPowerResourceD : public DStaticPowerResource

 	{

 public:

 	DStaticPowerResourceD(const TDesC8& aName, TInt aDefaultLevel);

 	TInt AddNode(SNode* aNode);

 	virtual TInt HandleChangePropagation(TPowerRequest aRequest, TPropagation aProp, TUint aOriginatorId, const TDesC8& aOriginatorName);

 	virtual TChangePropagationStatus TranslateDependentState(TInt aDepId, TInt aDepState, TInt& aResState) = 0;

 public:

 	SPowerResourceClientLevel* iResourceClientList; //To capture the dependent resource requirement on this resource

 	TDependencyCustomFunction iDepCustomFunction;

 private:

 	SNode* iDependencyList; //Dependency resource list

 	friend class DPowerResourceController;

 	};

 /**

 @publishedPartner

 @prototype 9.5

 class to represent dynamic resource with dependency

 */

 class DDynamicPowerResourceD : public DDynamicPowerResource

 	{

 public:

 	IMPORT_C DDynamicPowerResourceD(const TDesC8& aName, TInt aDefaultLevel);

 	IMPORT_C ~DDynamicPowerResourceD();

 	IMPORT_C virtual TInt HandleChangePropagation(TPowerRequest aRequest, TPropagation aProp, TUint aOriginatorId, const TDesC8& aOriginatorName);

 	virtual TChangePropagationStatus TranslateDependentState(TInt aDepId, TInt aDepState, TInt& aResState) = 0;

 public:

 	SPowerResourceClientLevel* iResourceClientList; //To capture the dependent resource requirement on this resource

 	TDependencyCustomFunction iDepCustomFunction;

 private:

 	SNode* iDependencyList; //Dependency resource list

 	friend class DPowerResourceController;

 	};

 /**

 @publishedPartner

 @prototype 9.5

 structure to represent resource dependency information. This is used when registering resource dependency

 */

 struct SResourceDependencyInfo

 	{

 	TUint iResourceId;

 	TUint8 iDependencyPriority;

 	};

 /**

 @publishedPartner

 @prototype 9.5

 structure to encapsulate dependent resource information. 

 */

 struct SNode

 	{

 	DStaticPowerResourceD* iResource;

 	TInt iPropagatedLevel;

 	TUint8 iRequiresChange;

 	TUint8 iVisited;

 	TUint8 iPriority;

 	TUint8 iSpare;

 	SNode* iNext;

 	};

 #endif