Symaptic: os/kernelhwsrv/kernel/eka/include/drivers/resource.h@260cb5ec6c19

     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 // e32\include\drivers\resource.h

    15 //

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

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

    18 //          outside the Kernel and Hardware Services package.

    19 //

    21 #ifndef __RESOURCE_H__

    22 #define __RESOURCE_H__

    23 #include <kernel/kernel.h>

    24 #include <kernel/kern_priv.h>

    25 #include <drivers/resourcecontrol_trace.h>

    26 #include <drivers/resource_category.h>

    28 //Definition for resource flag setting. Used by PSL.

    29 static const TUint KTypeMask= 0x3;

    30 static const TUint KUsageOffset=0x1F;

    31 static const TUint KLongLatencySetOffset=0x1E;

    32 static const TUint KLongLatencyGetOffset=0x1D;

    33 static const TUint KClassOffset=0x1C;

    34 static const TUint KSenseOffset=0x1A;

    35 static const TUint KShared=0x1<<KUsageOffset;

    36 static const TUint KLongLatencySet=0x1<<KLongLatencySetOffset;

    37 static const TUint KLongLatencyGet=0x1<<KLongLatencyGetOffset;

    38 static const TUint KLogical=0x1<<KClassOffset;

    39 static const TUint KSenseNegative=0x01<<KSenseOffset;

    40 static const TUint KSenseCustom=0x2<<KSenseOffset;

    42 struct TPowerRequest;

    43 struct SIdleResourceInfo;

    46 /**

    47  * List of operations that a Custom Function may be informed of.

    48  *

    49  * @publishedPartner

    50  * @prototype 9.5

    51  */

    52 enum TCustomOperation

    53     {

    54 	/**

    55 	Client has requested the given level.

    56 	*/

    57 	EClientRequestLevel,

    59 	/**

    60 	Client has relinquished the given level.

    61     */

    62 	EClientRelinquishLevel,

    64 	/**

    65 	Client is changing the level.

    66 	*/

    67 	EClientChangeLevel,

    69 	/**

    70 	A dynamic resource is being deregistered.

    71 	*/

    72 	EDynamicResourceDeregister

    73 	};

    76 /**

    77  *  Function prototype for the Custom Function.

    78  *

    79  *  @publishedPartner

    80  *  @prototype 9.5

    81  */

    82 typedef TBool (*TCustomFunction) (TInt& /*aClientId*/,

    83 								  const TDesC8& /*aClientName*/,

    84                                   TUint /*aResourceId*/,

    85                                   TCustomOperation /*aCustomOperation*/,

    86                                   TInt& /*aLevel*/,

    87                                   TAny* /*aLevelList*/,

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

    90 /**

    91 @publishedPartner

    92 @prototype 9.5

    93 class to represent static resources

    94 */

    95 class DStaticPowerResource : public DBase

    96 	{

    97 public:

    98     enum TType {EBinary = EResBinary, EMultilevel, EMultiProperty};

    99     enum TUsage {ESingleUse = EResSingleUse, EShared};

   100     enum TLatency {EInstantaneous = EResInstantaneous, ELongLatency};

   101     enum TClass {EPhysical = EResPhysical, ELogical};

   102     enum TSense {EPositive = EResPositive, ENegative, ECustom};

   103 public:

   104     //exported to allow construction from other base port components.

   105     IMPORT_C DStaticPowerResource(const TDesC8& aName, TInt aDefaultLevel);

   106     IMPORT_C virtual TInt GetInfo(TDes8* aInfo)const;

   107     inline void SetCustomFunction(TCustomFunction aCustomFunction)

   108            {iCustomFunction=aCustomFunction;}

   110     //private data inlined accessors

   111     TType Type() const {return TType(iFlags&KTypeMask);}

   112     TClass Class() const {return TClass((iFlags>>KClassOffset)&0x1);}

   113     TUsage Usage() const {return TUsage((iFlags>>KUsageOffset)&0x1);}

   114     TLatency LatencyGet() const

   115              {return TLatency((iFlags>>KLongLatencyGetOffset)&0x1);}

   116     TLatency LatencySet() const

   117              {return TLatency((iFlags>>KLongLatencySetOffset)&0x1);}

   118     TSense Sense() const {return TSense((iFlags>>KSenseOffset)&0x3);}

   119 protected:

   120     //pure virtual function to be implement by PSL

   121     virtual TInt DoRequest(TPowerRequest& aRequest)=0;

   122 public:

   123 	HBuf8* iName;

   124 protected:

   125     TInt iPostBootLevel;

   126 	TInt iDefaultLevel;

   127 protected:

   128     TInt iCachedLevel;

   129 	TUint iResourceId;

   130     SDblQue iNotificationList;

   131     SDblQue iClientList;

   132     TCustomFunction iCustomFunction;

   133     TInt iLevelOwnerId;

   134     SIdleResourceInfo* iIdleListEntry;

   135 protected:

   136     TUint iFlags;

   137 #ifdef PRM_CONTROLLER

   138     friend class DPowerResourceController;

   139 #endif

   140 	};

   142 typedef void (*TPowerResourceCbFn)(TUint /*aClientId*/,

   143                                    TUint /*aResourceId*/,

   144                                    TInt /*aLevel*/,

   145 								   TInt /*aLevelOwnerId*/,

   146                                    TInt /*aResult*/,

   147                                    TAny* /*aParam*/);

   149 /**

   150 @publishedPartner

   151 @prototype 9.5

   152 An object of this type prepresents a customised Dfc

   153 used to signal completion of the resource manager's asynchronous APIs

   154 and completion of notifications

   155 @see TPowerResourceManager

   156  */

   157 class TPowerResourceCb : public TDfc

   158 	{

   159 public:

   160 	inline TPowerResourceCb(TPowerResourceCbFn aFn, TAny* aPtr, TInt aPriority) : TDfc(DfcFunc, this, aPriority),

   161 		                                                            iParam(aPtr), iCallback(aFn){ }

   162 	inline TPowerResourceCb(TPowerResourceCbFn aFn, TAny* aPtr, TDfcQue* aQue, TInt aPriority):

   163 	                              TDfc(DfcFunc, this, aQue, aPriority), iParam(aPtr), iCallback(aFn) { }

   164 private:

   165     inline static void DfcFunc(TAny* aPtr)

   166         {

   167         TPowerResourceCb* pCb = (TPowerResourceCb*) aPtr;

   168 	    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TPowerResourceCb::DfcFunc ClientId = 0x%x, ResourceId = %d, Level = %d, \

   169 			                    LevelOwnerId = %d, Result = %d", pCb->iClientId, pCb->iResourceId, pCb->iLevel, \

   170 								pCb->iLevelOwnerId, pCb->iResult));

   171 	    // Call the client specified callback function

   172         pCb->iCallback(pCb->iClientId, pCb->iResourceId, pCb->iLevel, pCb->iLevelOwnerId, pCb->iResult, pCb->iParam);

   173 		pCb->iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.

   174         PRM_CALLBACK_COMPLETION_TRACE

   175         }

   176 private:

   177     TAny* iParam; //Stores the aPtr argument passed in the constructor, to be passed as 5th argument to the callback function

   178     TInt iResult; //Used to store the result aswell as binary usage count for the callback

   179     TInt iLevel; // Level of the resource

   180 	TInt iLevelOwnerId; // Stores owner of the resource for asynchronous get operation

   181     TUint iResourceId; //Stores the ID of the resource whose state is changed/read asynchronously

   182     TUint iClientId; //Stores the ID of the client that requested the asynchronous operation

   183     TPowerResourceCbFn iCallback; //Callback function object

   184 #ifdef PRM_CONTROLLER

   185     friend class DPowerResourceController;

   186 #endif

   187 	};

   189 /**

   190 @publishedPartner

   191 @prototype 9.5

   192 Notifications class. Conditional and unconditional notifications are encapsulated in this class.

   193 It uses TPowerResourceCb to perform the actual notification call.

   194 @see TPowerResourceCb

   195  */

   196 class DPowerResourceNotification : public DBase

   197     {

   198 public:

   199     enum TType {EUnconditional, EConditional};

   200 	enum TResNotiPanic {ENotificationObjectStillInList = 25};

   201 public:

   202 	inline DPowerResourceNotification(TPowerResourceCbFn aFn, TAny* aPtr, TInt aPriority):

   203 	                                                 iCallback(aFn, aPtr, aPriority) {}

   204 	inline DPowerResourceNotification(TPowerResourceCbFn aFn, TAny* aPtr, TDfcQue* aQue, TInt aPriority) :

   205 	                                                 iCallback(aFn, aPtr, aQue, aPriority) {}

   206 	inline ~DPowerResourceNotification()

   207 		{

   208 		if(iRegistered)

   209 			Kern::Fault("Power Resource Controller", ENotificationObjectStillInList);

   210 		}

   211 public:

   212 	TInt iPreviousLevel; //Previous level of the resource. This is used for checking the threshold condition

   213 	TUint8 iRegistered;

   214 private:

   215     TUint8 iType; // the type of notification required (conditional or unconditional).

   216     TUint16 iOwnerId; // the bottom 16 bits of the Id of the client which requested the notification

   217     TInt iThreshold; // the threshold which when crossed on a specified direction will cause a notification to be issued.

   218     TBool iDirection; // the direction of the resource change that together with the threshold to be crossed will result in the notification

   219     TPowerResourceCb iCallback; //Callback object associated with this notification

   220     SDblQueLink iNotificationLink;

   221     DPowerResourceNotification* iNextInClient;

   222 #ifdef PRM_CONTROLLER

   223     friend class DPowerResourceController;

   224 #endif

   225 	};

   227 /**

   228 @publishedPartner

   229 @prototype 9.5

   230 class to represent resource properties

   231 */

   232 class TPowerResourceInfoV01

   233 	{

   234 public:

   235     DStaticPowerResource::TClass iClass;

   236     DStaticPowerResource::TLatency iLatencyGet;

   237     DStaticPowerResource::TLatency iLatencySet;

   238     DStaticPowerResource::TType iType;

   239     DStaticPowerResource::TUsage iUsage;

   240     DStaticPowerResource::TSense iSense;

   241     TDesC8* iResourceName;

   242     TUint iResourceId;

   243     TInt iDefaultLevel;

   244     TInt iMinLevel;      //PSL mandatory field

   245     TInt iMaxLevel;      //PSL mandatory field

   246 	TInt iReserved1;	 //Reserved for future use.

   247 	TInt iReserved2;	 //Reserved for future use.

   248 	TInt iReserved3;	 //Reserved for future use.

   249     TInt iPslReserved1;  //PSL specific field

   250     TInt iPslReserved2;  //PSL specific field

   251     TInt iPslReserved3;  //PSL specific field

   252 	};

   254 /**

   255 @publishedPartner

   256 @prototype 9.5

   257 */

   258 typedef TPckgBuf<TPowerResourceInfoV01> TPowerResourceInfoBuf01;

   260 /**

   261 @publishedPartner

   262 @prototype 9.5

   263 structure to represent client properties

   264 */

   265 struct TPowerClientInfoV01

   266 	{

   267     TUint iClientId;

   268     TDesC8* iClientName;

   269 	};

   271 #endif // __RESOURCE_H__

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--