Initial contribution of the Adaptation Documentation.
<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) 2007-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:
-->
<!DOCTYPE concept
PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd">
<concept id="GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671" xml:lang="en"><title> Implement
the controllable power resources</title><shortdesc>This document describes how to write and use power resources. </shortdesc><prolog><metadata><keywords/></metadata></prolog><conbody>
<section id="GUID-7E91DB93-F9D6-4B93-8BAF-E25642F63C57"><title>Purpose</title> <p>Implement your power resource according
to the type of resource you wish to support. </p> <p><b>Introduction</b> </p> <p>Power
resources controlled by the PRM can be turned on, off and varied with software. </p> <p>See
the <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-4CC0C003-1952-5CAD-A7C5-163C5DDA52C8">Power
resources</xref> section for detailed information about resources. There are
five main types of resource that can be implemented: </p> <ul>
<li id="GUID-C67FB012-A1D6-5047-AD5A-18CF62971B2B"><p>static resources - derived
from the <xref href="GUID-DB7DDF4C-57EF-34FF-B3CD-13C5CD51A125.dita"><apiname>DStaticPowerResource</apiname></xref> base class, </p> </li>
<li id="GUID-6170B4D1-2AAD-52C7-88E0-D6BBE8CAFF63"><p>static resource that
support dependancy - derived from the <xref href="GUID-88C28976-67DF-3109-8D35-FA30A733C581.dita"><apiname>DStaticpowerResourceD</apiname></xref> base
class, </p> </li>
<li id="GUID-FAE7BFE3-7C2D-5DB7-A8FF-B7E4F37F5BAF"><p>dynamic resources -
derived from the <xref href="GUID-CA01041D-8FD6-3B5B-BB5D-A5159DF7C9AB.dita"><apiname>DDynamicPowerResource</apiname></xref> base class. Create
dynamic resources in the kernel data section or in the heap, </p> </li>
<li id="GUID-9586824D-FB68-5DC1-B743-9ED551FA286D"><p>dynamic resource that
support dependancy - derived from the <xref href="GUID-6B224A9F-D2B9-3289-922D-766EF093FCD6.dita"><apiname>DDynamicPowerResourceD</apiname></xref>. </p> </li>
<li id="GUID-AF8A571A-2AB6-5063-BFA5-3FF8509C95C7"><p>custom sense resources
- when shared the power level of this resource may be increased or decreased
freely by some privileged clients but not by others, which are bound by the
requirement of the privileged clients. </p> </li>
</ul> <p> <b>Note</b>: dynamic resources and resource dependancies are only
supported in the extended version of the PRM. See <xref href="GUID-2ECF13A1-9D56-5740-A09F-8267E6A45DD9.dita#GUID-2ECF13A1-9D56-5740-A09F-8267E6A45DD9/GUID-0F328055-DBCE-5B2B-A1EB-77F73BA1FC82">setup and configuration requirements</xref>. </p> </section>
<section id="GUID-D50E75DC-115E-42FD-9111-7A70E3087F33"><title> Implementing power resources </title> <p>The following tasks
are covered in this tutorial: </p> <ul>
<li id="GUID-2C4FDE84-401B-5520-B050-9FD475A63863">Create your resource by <p> <xref href="GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671.dita#GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671/GUID-3021B2EA-9829-515C-9074-2D2D0D7A5510">Override
the pure virtual functions</xref>, </p> </li>
<li id="GUID-6492CDEF-524E-5A3A-82AB-1D0E0B8E9D28"><p> <xref href="GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671.dita#GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671/GUID-A5D57D89-4499-5C85-80D5-5A7DC5644983">Create resource dependencies</xref>, </p> </li>
<li id="GUID-56A63835-D0B5-5C32-95D0-623A0D21AEF4"><p> <xref href="GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671.dita#GUID-B1CE51BC-B452-5FC9-9C00-35447AF40671/GUID-9526B472-00ED-583A-8BFC-C02363D4DFA2">Create custom resources</xref>. </p> </li>
</ul> <p id="GUID-3021B2EA-9829-515C-9074-2D2D0D7A5510"><b>Override the pure
virtual functions</b> </p> <p>The pure virtual functions of <xref href="GUID-DB7DDF4C-57EF-34FF-B3CD-13C5CD51A125.dita"><apiname>DStaticPowerResource</apiname></xref> or <xref href="GUID-CA01041D-8FD6-3B5B-BB5D-A5159DF7C9AB.dita"><apiname>DDynamicPowerResource</apiname></xref> must
be implemented. </p> <p><b>Constructor</b> </p> <p>Information about the resource
based on the resources category must be set in the <codeph>iFlags</codeph> bit
mask. Static variables that define a resources classification can be found
within <filepath>32\include\drivers\resource.h</filepath>. </p> <p>Each resource
is classified based on: </p> <ul>
<li id="GUID-08E6311D-6403-56CB-B91B-57C93F8CA208"><p>usage, </p> </li>
<li id="GUID-55F93FDB-137F-51D3-A1E3-F048B279425E"><p>operating levels, </p> </li>
<li id="GUID-4DD3D8E1-273A-5BFE-8A65-11B9DDE84E4D"><p>latency, </p> </li>
<li id="GUID-9B00B021-E620-50EA-B2D2-2F18111F5C1E"><p>resource sense. </p> </li>
</ul> <p>Below is the example implementation of derived class constructor </p> <codeblock id="GUID-1DE1E1CA-7212-5E30-85BF-C67578F9CEC8" xml:space="preserve">// multilevel, shared, long latency, read and write, positive resource.
DMLSHLGLSPResource::DMLSHLGLSPResource() : DStaticPowerResource(KDBSHLGLSPResource, E_ON),
iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue)
{
iFlags = EMultilevel | KShared | KLongLatencySet | KLongLatencyGet;
. . .
}</codeblock> <p><b> GetInfo()</b> </p> <p>The PIL uses <xref href="GUID-66D96ADA-1C26-3293-9F92-FD65E08D6158.dita"><apiname>GetInfo()</apiname></xref> to
get resource information. The default implementation of this function provides
generic information about the resource by updating the passed descriptor that
contains an information structure <xref href="GUID-FA4D9A07-041C-303C-BF96-2E444DD47024.dita"><apiname>TPowerResourceInfoV01</apiname></xref>.
Derived implementations must fill in all the PSL specific fields and call
the base class implementation. Below is an example implementation. </p> <codeblock id="GUID-EB61E8FF-146C-5825-8F16-869FE4DD5B44" xml:space="preserve">TInt DH4SndFclkResource::GetInfo(TDes8* info) const
{
__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DH4SndFclkResource::GetInfo\n"));
/** Call base class implementation to fill generic details */
DStaticPowerResource::GetInfo((TDes8*) info);
TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*) info;
buf1->iMinLevel = iMinLevel;
buf1->iMaxLevel = iMaxLevel;
__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DH4SndFclkResource::GetInfo\n"));
return KErrNone;
}</codeblock> <p>The member variables of the <codeph>TPowerResourceInfoV01</codeph> structure
are reserved for PSL information. These can be used to return resource specific
information to clients. </p> <p><b>DoRequest()</b> </p> <p> <xref href="GUID-9D910016-5611-30DD-A139-EE46705A4912.dita"><apiname>DoRequest()</apiname></xref> is
used by the PIL to control resources. For example, to change and read the
state of resources. <codeph>DoRequest()</codeph> takes a <xref href="GUID-D204F4A7-8CC8-3EB2-8371-1D1BFD903390.dita"><apiname>TPowerRequest</apiname></xref> object
that contains all the request information. <b>Note</b>: This function needs
to be implemented for all resources. </p> <p>Below is an example <xref href="GUID-9D910016-5611-30DD-A139-EE46705A4912.dita"><apiname>DoRequest()</apiname></xref> function
implementation for a binary, instantaneous resource. </p> <codeblock id="GUID-D5AE04C1-7A9D-5270-840F-6CD662FB46A2" xml:space="preserve">TInt DH4MmcCtrllerPwrResource::DoRequest(TPowerRequest& aRequest)
{
TInt retVal = KErrNone;
TUint16 config;
/** Enable/disable the MMC controller by programming the MMC controller 'CON' register- 'POW' bit */
if (aRequest.ReqType()==TPowerRequest::EGet)
{
PRM_PSL_RESOURCE_GET_STATE_START_TRACE
config = OMAPMMC_GET_REG(KHoMMC_Con_Reg);
if(config & KHtMMC_PowerUp)
{
aRequest.Level() = 1;
iCurLevel = 1;
}
else
{
aRequest.Level() = 0;
iCurLevel = 0;
}
PRM_PSL_RESOURCE_GET_STATE_END_TRACE
}
else if(aRequest.ReqType()==TPowerRequest::ESetDefaultLevel)
{
PRM_PSL_RESOURCE_CHANGE_STATE_START_TRACE
OMAPMMC_MOD_REG(KHoMMC_Con_Reg, KHtMMC_PowerUp, KClear32);
iCurLevel = iDefaultLevel;
aRequest.Level() = iDefaultLevel;
PRM_PSL_RESOURCE_CHANGE_STATE_END_TRACE
}
else
{
PRM_PSL_RESOURCE_CHANGE_STATE_START_TRACE
if(aRequest.Level() == 1)
{
OMAPMMC_MOD_REG(KHoMMC_Con_Reg, KClear32, KHtMMC_PowerUp);
}
else
{
OMAPMMC_MOD_REG(KHoMMC_Con_Reg, KHtMMC_PowerUp, KClear32);
}
iCurLevel = aRequest.Level();
PRM_PSL_RESOURCE_CHANGE_STATE_END_TRACE
}
return retVal;
}</codeblock><p>The DoRequest function implementation should take care
of blocking the Resource Controller thread as operations on a long latency
resource take a significant amount of time to complete (in hardware). Usually
the request completion is notified either through an ISR (interrupt driven)
or through register setting (polling wait) by hardware. </p><p>Below is an
example <codeph>DoRequest()</codeph> implementation for a long latency resource. </p> <codeblock xml:space="preserve"> TInt DH4MmcPowerResource::DoRequest(TPowerRequest& aRequest)
{
TUint8 iMenelausConf;
TInt retVal = KErrNone;
/** Access to Menelaus registers is over I2C bus. This is a long latency synchronous operation.
Create a Menelaus Request structure and send it to Menelaus chip, Wait until a response is received */
if (aRequest.ReqType()==TPowerRequest::EGet)
{
// Frame the request
...
}
// Default level is off.
else if (aRequest.ReqType() == TPowerRequest::ESetDefaultLevel)
{
// Frame request to move the resource to default state
...
}
// EChange
else
{
// Frame request to set the requested resource state
...
}
// Request the operation on the hardware
retVal = Menelaus::AccessRegister(iMenelausReq);
// Wait for the request to complete
__KTRACE_OPT(KPBUS1, Kern::Printf("Waiting for menelaus req to signal sem\n"));
NKern::FSSetOwner(&iSemaphore,NULL);
iSemaphore.iCount = 0;
// This will be signalled in Menelaus access functions callback below
NKern::FSWait(&(iSemaphore));
// Menelaus chip has responded
if(iMenelausAccessErr == KErrNone)
{
switch(iMenelausState)
{
case EMenelausRead:
// Return 0/1 depending on the value set
iMenelausConf = (*(iRdBuffer.Ptr())) & KHoMenelausVmmcModeMask;
if(iMenelausConf == 3)
{
iCurLevel=aRequest.Level()=1;
}
else
{
iCurLevel=aRequest.Level()=0;
}
PRM_PSL_RESOURCE_GET_STATE_END_TRACE
break;
case EMenelausSingleWrite:
iCurLevel = aRequest.Level();
PRM_PSL_RESOURCE_CHANGE_STATE_END_TRACE
break;
}
}
return iMenelausAccessErr;
}
/** Below is the Menelaus access functions callback where the semaphore is signalled. */
void DH4MmcPowerResource::MenelausAccessDone(TAny* aPtr, TInt aResult)
{
DH4MmcPowerResource* ptr = reinterpret_cast<DH4MmcPowerResource*>(aPtr);
ptr->iMenelausAccessErr = aResult;
if(aResult != KErrNone)
{
__KTRACE_OPT(KRESMANAGER,
Kern::Printf("Menelaus::MenelausAccessRegister ERR(%d)\n", aResult));
}
// Signal the waiting thread
NKern::FSSignal(&(ptr->iSemaphore));
return;
}</codeblock><p id="GUID-A5D57D89-4499-5C85-80D5-5A7DC5644983"><b>Create
resource dependencies</b> </p> <p>A resource has a dependency if the state
of the resource depends on the state of one or more resources. For example,
a clock whose frequency is derived from another clock or voltage is a dependent
resource. The PSL usually handles resource dependencies transparently. However,
if the resources have public users (clients of the PRM), then these resources
should be registered with the PRM as <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-473BBE32-6831-52BE-8752-CB6DBBBABD2C">Resource
dependencies</xref> that are linked. </p> <p>Each dependency must be assigned
a priority value. The priority is used by the PIL when propagating the change
and propagating the request for notifications. Each link stemming from a resource
must have a unique priority value. </p> <p> <b>Note</b>: Resource dependencies
are only supported in the extended version of the PRM. Only long latency resources
are allowed to have dependents and no closed loop dependencies are allowed. </p> <p><b> Register
resource dependencies for dynamic and static resources</b> </p> <p>Static
resources that support dependencies are created and registered with the PRM
during resource controller creation time and are derived from <codeph>DStaticPowerResourceD</codeph>: </p> <codeblock id="GUID-1C7E2D5F-8C76-5D4D-84FA-259DE943742E" xml:space="preserve">DXXXStaticPowerResourceD : public DStaticPowerResourceD
{
public:
DXXXStaticPowerResourceD();
TInt DoRequest(TPowerRequest &req);
TInt GetInfo(TDes8* aInfo) const;
TChangePropagationStatus TranslateDependentState(TInt aDepId, TInt aDepState, TInt& aResState);
private:
TInt iMinLevel;
TInt iMaxLevel;
TInt iCurrentLevel;
...
};</codeblock> <p>Dependencies between static resources should be established
by the PSL before registering these resources with the PIL. Use the <xref href="GUID-1CD49D40-1FF9-301C-8160-02A007485ADE.dita#GUID-1CD49D40-1FF9-301C-8160-02A007485ADE/GUID-806D0179-FC98-3106-BCBA-0D3634B43815"><apiname>DStaticPowerResourceD::AddNode()</apiname></xref> function
provided in the base class to establish a dependency link between static resources.
See <xref href="GUID-66FD040B-133E-57CF-80DD-9369F62709C6.dita#GUID-66FD040B-133E-57CF-80DD-9369F62709C6/GUID-A912A328-D646-5516-9731-FFA7F3B2EDDA">Creating
dependencies between static resources</xref>. </p> <p>Dynamic resources that
support dependency are derived from <xref href="GUID-6B224A9F-D2B9-3289-922D-766EF093FCD6.dita"><apiname>DDynamicPowerResourceD</apiname></xref>.
These can be registered and deregistered from the PRM at any time after the
PRM is fully initialised. Dependencies between resources are established by
the client using <xref href="GUID-40AB9EDA-16CB-371E-8759-1D7C99FF9C00.dita#GUID-40AB9EDA-16CB-371E-8759-1D7C99FF9C00/GUID-9C1BF3D5-6F5D-3BEF-9DF0-A5FED85CC718"><apiname>PowerResourceManager::RegisterResourceDependency()</apiname></xref>. </p> <codeblock id="GUID-30B2271B-FA2A-53FE-A1F1-0A3E36B95883" xml:space="preserve">DXXXDynamicPowerResourceD : public DDynamicPowerResourceD
{
public:
DXXXDynamicPowerResourceD();
TInt DoRequest(TPowerRequest &req);
TInt GetInfo(TDes8* aInfo) const;
TChangePropagationStatus TranslateDependentState(TInt aDepId, TInt aDepState, TInt& aResState);
private:
TInt iMinLevel;
TInt iMaxLevel;
TInt iCurrentLevel;
...
};</codeblock> <p>Dependencies can be established between a dynamic resource
and a static (dependency enabled) resource using the same API. A client can
deregister dependencies between a pair of dynamic resource (or between a dynamic
and static resource) using <xref href="GUID-40AB9EDA-16CB-371E-8759-1D7C99FF9C00.dita#GUID-40AB9EDA-16CB-371E-8759-1D7C99FF9C00/GUID-127E979F-F540-36E2-A759-8ED408E89F38"><apiname>PowerResourceManager::DeRegisterResourceDependency()</apiname></xref>.
When a dynamic resource that supports dependency deregisters from the PRM,
dependencies are removed automatically by the PIL. </p> <p><b>Change the state
of dependent resources</b> </p> <p>When a state change is requested by a client
on any resource in a dependency tree before proceeding with the change the
PIL must check if the change is allowed by its dependents and the ones it
depends on. The PIL does this by calling the <xref href="GUID-E71F94F6-A4BB-3C85-8E2E-8E3ABAA85897.dita"><apiname>TranslateDependentState()</apiname></xref> function
on each resource. This is a pure virtual function in the base class and must
be implemented in the derived class. </p> <p>This function is called by the
PIL prior to a resource change on any of its dependents. The function returns
one of these values: </p> <ul>
<li id="GUID-CEABEBE0-34BB-5CD0-861E-CDB87A066C8B"><p> <codeph>EChange</codeph> -
If the resource accepts the state change of the dependent resource and, as
a result of the dependent resources state change this resource needs to change
its own state. The new state of this resource is updated in <codeph>aResState</codeph>, </p> </li>
<li id="GUID-A22403B9-38C9-571E-9E14-C7BD1CB032F2"><p> <codeph>ENoChange</codeph> -
if the resource accepts the dependent resources state change and this resource
does not need to change its state, </p> </li>
<li id="GUID-EE30E093-85A0-5205-B1C7-6C36A5410BB1"><p> <codeph>ENotAllowed</codeph> -
if the resource does not accept the dependent resources state change. </p> </li>
</ul> <codeblock id="GUID-453D7F61-4187-50DC-B641-34A06AEB722B" xml:space="preserve">TChangePropagationStatus DXXDependResource::TranslateDependentState(TInt /*aDepId*/, TInt aDepState,
TInt& aResState)
{
/* Switch ON if the dependent resource is ON */
if((aDepState == 1) && (iCurrentLevel == 0)
{
aResState = iMaxLevel;
return EChange;
}
/* Don’t allow dependent to OFF, if this is still ON */
else if (aDepState == 0) && (iCurrentLevel == 1)
{
return ENotAllowed;
}
return ENoChange;
}</codeblock> <p id="GUID-9526B472-00ED-583A-8BFC-C02363D4DFA2"><b>Create
custom resources</b> </p> <p>Clients on a shared resource may have different
requirements on the state of a shared resource. The resource sense is used
by the PIL to determine whose requirement prevails: </p> <ul>
<li id="GUID-495628CC-D257-598F-B420-2784749B1083"><p>positive sense resources
- when shared can have their value increased without prejudice to their clients, </p> </li>
<li id="GUID-D4D7CB6D-F99B-568E-9F38-429196599F4F"><p>negative sense resources
- when shared can have their value decreased without prejudice to their clients, </p> </li>
<li id="GUID-0BB26EA3-F22B-5C7D-8999-14DB75D066CA"><p>custom sense resources
- when shared may be increased or decreased freely by some privileged clients
but not by others, which are bound by the requirement of the privileged clients. </p> </li>
</ul> <p>A custom function must be supplied for every <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-4CC0C003-1952-5CAD-A7C5-163C5DDA52C8">Power resources</xref> resource. This function is called by the PIL every
time a change request is issued to determine if the change requested by the
client is allowed as a decision to allow the resource change is determined
solely by the PSL. The resource object contains a pointer that must be set
at construction for custom sense resources by calling this function: </p> <codeblock id="GUID-31716524-4902-5E87-A51F-2EF63DA6D500" xml:space="preserve">inline void SetCustomFunction(TCustomFunction aCustomFunction)</codeblock> <p>This
function sets the custom function for the resource. If a custom function is
not supplied for a custom sense resource the PIL panics during a resource
state change. An example of a custom sense resource is a shared domain clock
when a domain client uses it as a bit clock. </p> <p> <xref href="GUID-5FDBF9F8-9BC4-3E3B-9A28-5046C65788E2.dita"><apiname>TCustomFunction</apiname></xref> is
a function pointer: </p> <codeblock id="GUID-A0ECC7F5-A410-50DA-9723-09C1C080927C" xml:space="preserve">typedef TBool (*TCustomFunction) (TInt& /*aClientId*/,
TUint /*aResourceId*/,
TInt& /*aLevel*/,
TAny* /*aLevelList*/);</codeblock> <p>The
values held in TCustomFunction are: </p> <ul>
<li id="GUID-5E1EF546-098D-5940-8BD0-4AF2B70861E4"><p>the Id of the client
requesting the change, </p> </li>
<li id="GUID-A8E1B48A-C36C-5D88-9388-BE40902832AE"><p>the Id of the resource
on which the change is requested (this allows a single function to handle
multiple resources), </p> </li>
<li id="GUID-CDC2D3F7-2E82-5E56-864B-E0901B57FE83"><p>the level the client
is requesting, </p> </li>
<li id="GUID-57C1C8CC-411D-54B7-9548-2D0C5DFB6B3F"><p>a pointer to the list
of the resource’s <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-F47D2098-16A7-5590-A68A-7AE4B2DAB462">client
levels</xref>. </p> </li>
</ul> <p>Custom functions can be set at any time before a resource state change
is requested on a resource. Ideally a custom function is set at resource creation
time in the resource's constructor. </p> <codeblock id="GUID-6B688BFC-8D7A-5D7C-B17D-B4D3579230F4" xml:space="preserve">DBSHLGLSCResource::DBSHLGLSCResource() : DStaticPowerResource(KDBSHLGLSCResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(EFalse)
{
iFlags = KMultiLevel | KShared | KLongLatencySet | KSenseCustom;
SetCustomFunction(CustomFunction);
...
}</codeblock> <p>The decision to allow the requested resource state change
is specified in the custom function return value. This is <codeph>ETrue</codeph> if
the change is allowed and <codeph>EFalse</codeph> if the change is not allowed. </p> <p>The
function can change the state of the resource to a level other than the one
requested and can choose a client other than the passed client to hold the <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-121C14E3-D446-565E-AAAE-C43C131ACD3C">Caching
the prevailing level</xref> of the resource. </p> <p><b>Supporting dependencies </b> </p> <p>If
the custom sense resource supports dependencies then use the function pointer <xref href="GUID-60A17842-3E3B-3748-8F91-F5ED912E642A.dita"><apiname>TDependencyCustomFunction</apiname></xref>.
This takes an additional parameter that specifies the resource <xref href="GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE.dita#GUID-6E1DE1E4-1B09-541C-8708-9126E69B42CE/GUID-F47D2098-16A7-5590-A68A-7AE4B2DAB462">Client level objects</xref>. </p> </section>
</conbody><related-links>
<link href="GUID-2ECF13A1-9D56-5740-A09F-8267E6A45DD9.dita"><linktext>Porting the
Power Resource Manager</linktext></link>
<link href="GUID-66FD040B-133E-57CF-80DD-9369F62709C6.dita"><linktext>Implement
the PSL for the target</linktext></link>
<link href="GUID-E7F91A65-235D-589C-9A8C-0B207D19A24B.dita"><linktext>Port the
client drivers to use the PRM</linktext></link>
<link href="GUID-C8DF0CB0-92F4-5F9E-A8F1-7DE50954C4F1.dita"><linktext>Debugging
the PRM</linktext></link>
<link href="GUID-66E5F769-1156-54CA-94BC-8912159A1240.dita"><linktext>Testing the
PRM PSL</linktext></link>
</related-links></concept>