Merged Keystone II to master for initial release
authorJustin Sobota <jsobota@ti.com>
Tue, 12 Feb 2013 22:59:48 +0000 (17:59 -0500)
committerJustin Sobota <jsobota@ti.com>
Tue, 12 Feb 2013 22:59:48 +0000 (17:59 -0500)
1  2 
.gitignore
build/buildlib.xs
docs/RM_SoftwareManifest.pdf
docs/ReleaseNotes_RM.doc
docs/ReleaseNotes_RM.pdf
package.xdc
src/rm.c

diff --cc .gitignore
index 0000000000000000000000000000000000000000,b43267ae6c383b6638a32b181dbd94e21c79ede8..94f53b3d10155a309032d80aabc54507072b7fe3
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,20 +1,21 @@@
+ *.swp
+ *~
+ *.bak
++*.orig
+ .dlls
+ .executables
+ .interfaces
+ .libraries
+ .xdcenv.mak
+ Settings.h
+ Settings.xdc
+ build/c66/
+ docs/Doxyfile
+ docs/doxygen/
+ docs/rmDocs.chm
+ lib/
+ makefile
+ package.mak
+ package/
+ packages/
+ rmver.h
Simple merge
index 0000000000000000000000000000000000000000,24528dcf45638e7d4db8f497a18171c0f465f295..7cb930c86d54fc947fa090b90ea0cefc9d8da39f
mode 000000,100644..100644
Binary files differ
index 2279161e4cdf7dd7cab2b6a710c11c19a37cf00d,e7fe5fc3181d4f1eb2599898ba7203b89677bfc7..97cc97c488b4401ff7d34cb82cfd61e05dab4d57
Binary files differ
index 0000000000000000000000000000000000000000,1e97011436a37230f43861ff4b81345b4b555d5d..ee44920b1458b0c3be637722b20693cf4b3d16e6
mode 000000,100644..100644
Binary files differ
diff --cc package.xdc
index 34850af45f0f7664251b57c113bd3aa85e086cd6,8e57aabaa6f5a072d364ee0bbfee22b90f774095..50fee562c88030028fc8ffcffe43386a56d738d4
@@@ -4,12 -4,11 +4,11 @@@
   * FILE NAME: package.xdc\r
   *\r
   * DESCRIPTION: \r
-  *  This file contains the package specification for the RM LLD library\r
+  *  This file contains the package specification for the RM library\r
   *\r
-  * Copyright (C) 2012, Texas Instruments, Inc.\r
+  * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
   *****************************************************************************/\r
  \r
- package ti.drv.rm[02, 00, 00, 00] {\r
 -package ti.drv.rm[2, 0, 0, 0] {\r
++package ti.drv.rm[02, 00, 00, 01] {\r
      module Settings;\r
  }\r
\r
diff --cc src/rm.c
index 607eab17b6ed8d8788bbbcd02cf1abd76bd12e61,96dbf83ab7345f0fa936397e95fc49cc298d7865..c4ffbd8ec9e5c82c9fba6ba79a14cbc78203201d
+++ b/src/rm.c
 -/**\r
 - *   @file  rm.c\r
 - *\r
 - *   @brief   \r
 - *      This is the Resource Manager source.\r
 - *\r
 - *  \par\r
 - *  ============================================================================\r
 - *  @n   (C) Copyright 2012-2013, Texas Instruments, Inc.\r
 - * \r
 - *  Redistribution and use in source and binary forms, with or without \r
 - *  modification, are permitted provided that the following conditions \r
 - *  are met:\r
 - *\r
 - *    Redistributions of source code must retain the above copyright \r
 - *    notice, this list of conditions and the following disclaimer.\r
 - *\r
 - *    Redistributions in binary form must reproduce the above copyright\r
 - *    notice, this list of conditions and the following disclaimer in the \r
 - *    documentation and/or other materials provided with the   \r
 - *    distribution.\r
 - *\r
 - *    Neither the name of Texas Instruments Incorporated nor the names of\r
 - *    its contributors may be used to endorse or promote products derived\r
 - *    from this software without specific prior written permission.\r
 - *\r
 - *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
 - *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
 - *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
 - *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
 - *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
 - *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
 - *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
 - *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
 - *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
 - *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
 - *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
 - *\r
 - *  \par\r
 -*/\r
 -\r
 -/* Standard includes */\r
 -#include <stdint.h>\r
 -#include <string.h>\r
 -#include <stdbool.h>\r
 -\r
 -/* RM external includes */\r
 -#include <ti/drv/rm/rm.h>\r
 -#include <ti/drv/rm/rmver.h>\r
 -#include <ti/drv/rm/rm_services.h>\r
 -#include <ti/drv/rm/rm_transport.h>\r
 -\r
 -/* RM internal includes */\r
 -#include <ti/drv/rm/include/rm_loc.h>\r
 -#include <ti/drv/rm/include/rm_transportloc.h>\r
 -#include <ti/drv/rm/include/rm_nameserverloc.h>\r
 -#include <ti/drv/rm/include/rm_dtb_utilloc.h>\r
 -#include <ti/drv/rm/include/rm_policyloc.h>\r
 -#include <ti/drv/rm/include/rm_treeloc.h>\r
 -\r
 -/* RM LIBFDT includes */\r
 -#include <ti/drv/rm/util/libfdt/libfdt.h>\r
 -\r
 -/* Tree algorithm includes */\r
 -#include <ti/drv/rm/util/tree.h>\r
 -\r
 -/* RM OSAL layer */\r
 -#include <rm_osal.h>\r
 -\r
 -/**********************************************************************\r
 - ************************** Globals ***********************************\r
 - **********************************************************************/\r
 -\r
 -/** @brief Global Variable which describes the RM Version Information */\r
 -const char  rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;\r
 -\r
 -/**********************************************************************\r
 - ************************ Local Functions *****************************\r
 - **********************************************************************/\r
 -\r
 -/* FUNCTION PURPOSE: Initializes a RM inst's transaction sequence number\r
 - ***********************************************************************\r
 - * DESCRIPTION: The RM instance transaction sequence number can never\r
 - *              have a value of 0 to avoid conflicts with transactions\r
 - *              that have a remoteOriginatingId of 0 (transaction ID\r
 - *              will be used as the remoteOriginatingId for\r
 - *              transactions that are responses to requests).\r
 - */\r
 -static uint32_t transactionInitSequenceNum(void)\r
 -{\r
 -    return (1);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Provides a sequence number for new transactions\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a sequence number for a new transaction\r
 - *              specific to a RM instance.  Handles rollover of\r
 - *              sequence number.\r
 - */\r
 -static uint32_t transactionGetSequenceNum(Rm_Inst *rmInst)\r
 -{\r
 -    uint32_t sequenceNum = 0;\r
 -\r
 -    if (rmInst->transactionSeqNum + 1 < rmInst->transactionSeqNum) {\r
 -        /* Rollover */\r
 -        sequenceNum = rmInst->transactionSeqNum;\r
 -        rmInst->transactionSeqNum = transactionInitSequenceNum();\r
 -    }\r
 -    else {\r
 -        sequenceNum = rmInst->transactionSeqNum++;\r
 -    }    \r
 -    return (sequenceNum);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Creates a resource allocator\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a newly Created and initialized resource\r
 - *              The allocator is also stored in the RM instance\r
 - *              allocator list.            \r
 - */\r
 -static Rm_Allocator *allocatorAdd(Rm_Inst *rmInst, const char *resourceName)\r
 -{\r
 -    Rm_Allocator *allocators   = rmInst->allocators;\r
 -    Rm_Allocator *newAllocator = NULL;\r
 -\r
 -    newAllocator = Rm_osalMalloc(sizeof(Rm_Allocator));\r
 -\r
 -    if (newAllocator) {\r
 -        memset((void *)newAllocator, 0, sizeof(Rm_Allocator));\r
 -        strncpy(newAllocator->resourceName, resourceName, RM_NAME_MAX_CHARS);\r
 -        newAllocator->allocatorRootEntry = NULL;\r
 -        newAllocator->nextAllocator = NULL;  \r
 -\r
 -        /* Add allocator to end of list */\r
 -        if (allocators) {\r
 -            while (allocators->nextAllocator) {\r
 -                allocators = allocators->nextAllocator;\r
 -            }\r
 -            allocators->nextAllocator = newAllocator;\r
 -        }\r
 -        else {\r
 -            rmInst->allocators = newAllocator;\r
 -        }\r
 -    }\r
 -    return (newAllocator);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Deletes a resource allocator\r
 - ***********************************************************************\r
 - * DESCRIPTION: Deletes a resource allocator based on the given\r
 - *              resource name.  The resource allocator will be\r
 - *              removed from the RM instance allocator list.\r
 - */\r
 -static int32_t allocatorDelete(Rm_Inst *rmInst, char *resourceName)\r
 -{\r
 -    Rm_Allocator *allocator = rmInst->allocators;\r
 -    Rm_Allocator *prevAllocator = NULL;\r
 -    int32_t       retVal = RM_OK;\r
 -\r
 -    while (allocator) {\r
 -        if (strncmp(allocator->resourceName, resourceName, RM_NAME_MAX_CHARS) == 0) {\r
 -            break;             \r
 -        }\r
 -        prevAllocator = allocator;\r
 -        allocator = allocator->nextAllocator;\r
 -    }\r
 -\r
 -    if (allocator) {\r
 -        if (prevAllocator == NULL) {\r
 -            rmInst->allocators = allocator->nextAllocator;\r
 -        }\r
 -        else {\r
 -            prevAllocator->nextAllocator = allocator->nextAllocator;\r
 -        }\r
 -        Rm_osalFree((void *)allocator, sizeof(Rm_Allocator));\r
 -    }\r
 -    else {\r
 -        retVal = RM_ERROR_RES_ALLOCATOR_DOES_NOT_EXIST;\r
 -    }\r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Adds an owner to an allocator resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Adds a RM instance node to a resource node's\r
 - *              list of owners.\r
 - */\r
 -static void addOwner(Rm_ResourceNode *node, void *serviceInstNode)\r
 -{\r
 -    Rm_Owner *ownerList = node->ownerList;\r
 -    Rm_Owner *newOwner = NULL;\r
 -\r
 -    newOwner = Rm_osalMalloc(sizeof(Rm_Owner));\r
 -\r
 -    if (newOwner) {\r
 -        newOwner->instNameNode = serviceInstNode;\r
 -        newOwner->nextOwner = NULL;  \r
 -\r
 -        /* Add owner entry to end of list */\r
 -        if (ownerList) {\r
 -            while (ownerList->nextOwner) {\r
 -                ownerList = ownerList->nextOwner;\r
 -            }\r
 -            ownerList->nextOwner = newOwner;\r
 -        }\r
 -        else {\r
 -            node->ownerList = newOwner;\r
 -        }\r
 -\r
 -        node->allocationCount++;\r
 -        newOwner->instNameNode->allocRefCount++;\r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Checks a resource node's ownership\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns TRUE if the provided instance node is\r
 - *              in the list of resource node owners.  Otherwise,\r
 - *              returns FALSE.\r
 - */\r
 -static bool isOwnedBy(Rm_ResourceNode *node, void *serviceInstNode)\r
 -{\r
 -    Rm_Owner *owner = node->ownerList;\r
 -\r
 -    while (owner) {\r
 -        if (owner->instNameNode == serviceInstNode) {\r
 -            return(true);           \r
 -        }\r
 -        owner = owner->nextOwner;\r
 -    }\r
 -    return(false);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Compares two resource node's owners\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns TRUE if the owners of two resource nodes \r
 - *              are equivalent.  Otherwise, returns FALSE.\r
 - */\r
 -static bool compareResourceNodeOwners(Rm_ResourceNode *node1, Rm_ResourceNode *node2)\r
 -{\r
 -    Rm_Owner *node1Owners = node1->ownerList;\r
 -    Rm_Owner *node2Owners = node2->ownerList;\r
 -    bool      matchedInst;\r
 -\r
 -    if (node1->allocationCount == node2->allocationCount) {\r
 -        while (node1Owners) {\r
 -            matchedInst = false;\r
 -            while (node2Owners) {\r
 -                if (node1Owners->instNameNode == node2Owners->instNameNode) {\r
 -                    matchedInst = true;\r
 -                    break;\r
 -                }\r
 -                node2Owners = node2Owners->nextOwner;\r
 -            }\r
 -\r
 -            if (matchedInst) {\r
 -                node2Owners = node2->ownerList;\r
 -                node1Owners = node1Owners->nextOwner;\r
 -            }\r
 -            else {\r
 -                return(false);\r
 -            }                \r
 -        }\r
 -    }\r
 -    else {\r
 -        return(false);\r
 -    }  \r
 -    \r
 -    return(true);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Deletes an owner from an allocator resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Removes a RM instance node from a resource node's\r
 - *              list of owners.\r
 - */\r
 -static void deleteOwner(Rm_ResourceNode *node, void *serviceInstNode)\r
 -{\r
 -    Rm_Owner *owner = node->ownerList;\r
 -    Rm_Owner *prevOwner = NULL;\r
 -\r
 -    while (owner) {\r
 -        if (owner->instNameNode == serviceInstNode) {\r
 -            break;             \r
 -        }\r
 -        prevOwner = owner;\r
 -        owner = owner->nextOwner;\r
 -    }\r
 -\r
 -    if (prevOwner == NULL) {\r
 -        node->ownerList = owner->nextOwner;\r
 -    }\r
 -    else {\r
 -        prevOwner->nextOwner = owner->nextOwner;\r
 -    }\r
 -    \r
 -    node->allocationCount--;\r
 -    owner->instNameNode->allocRefCount--;\r
 -    Rm_osalFree((void *)owner, sizeof(Rm_Owner));\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Copies the owners of a resource node\r
 - ***********************************************************************\r
 - * DESCRIPTION: Creates a list of resource owners for the destination\r
 - *              resource node that is equivalent to the the \r
 - *              source resource node's owners\r
 - */\r
 -static void copyOwners(Rm_ResourceNode *dstNode, Rm_ResourceNode *srcNode)\r
 -{\r
 -    Rm_Owner *srcOwnerList = srcNode->ownerList;\r
 -    Rm_Owner *dstNewOwner;\r
 -    Rm_Owner *dstPrevOwner;\r
 -\r
 -    dstNode->allocationCount = srcNode->allocationCount;\r
 -\r
 -    while (srcOwnerList) {\r
 -        dstNewOwner = Rm_osalMalloc(sizeof(Rm_Owner));\r
 -        dstNewOwner->instNameNode = srcOwnerList->instNameNode;\r
 -        dstNewOwner->nextOwner = NULL;\r
 -\r
 -        if (dstNode->ownerList == NULL) {\r
 -            dstNode->ownerList = dstNewOwner;\r
 -        }\r
 -        else {\r
 -            dstPrevOwner->nextOwner = dstNewOwner;\r
 -        }\r
 -        dstPrevOwner = dstNewOwner;\r
 -        srcOwnerList = srcOwnerList->nextOwner;\r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Clears a resource node's owners\r
 - ***********************************************************************\r
 - * DESCRIPTION: Deletes all owners from the owners list of a \r
 - *              resource node.\r
 - */\r
 -static void clearOwners(Rm_ResourceNode *node)\r
 -{\r
 -    Rm_Owner *owner = node->ownerList;\r
 -    Rm_Owner *nextOwner;\r
 -\r
 -    while (owner) {\r
 -        nextOwner = owner->nextOwner;\r
 -        node->allocationCount--;\r
 -        Rm_osalFree((void *)owner, sizeof(Rm_Owner));\r
 -        owner = nextOwner;\r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Creates a new resource tree\r
 - ***********************************************************************\r
 - * DESCRIPTION: Creates a new resource tree using the provided\r
 - *              resource name and value range.  The name and value\r
 - *              typically originate from the GRL.\r
 - */\r
 -static int32_t createResourceTree(Rm_Inst *rmInst, const char *resourceName, Rm_ResourceRange *range)\r
 -{\r
 -    Rm_Allocator    *allocator = NULL;\r
 -    Rm_ResourceTree *treeRootEntry = NULL;\r
 -    Rm_ResourceNode *treeNode = NULL;\r
 -    Rm_ResourceNode *collidingNode = NULL;\r
 -\r
 -    allocator = allocatorAdd(rmInst, resourceName);\r
 -    treeRootEntry = Rm_osalMalloc(sizeof(Rm_ResourceTree));\r
 -    RB_INIT(treeRootEntry);\r
 -\r
 -    while (range != NULL) {\r
 -        treeNode = rmResourceNodeNew(range->base, range->length);\r
 -        collidingNode = RB_INSERT(_Rm_AllocatorResourceTree, treeRootEntry, treeNode);\r
 -\r
 -        if (collidingNode) {\r
 -            Rm_ResourceNode *nextNode = NULL;\r
 -            \r
 -            /* Node that was inserted collides with existing node.  Destroy tree and return error */\r
 -            for (treeNode = RB_MIN(_Rm_AllocatorResourceTree, treeRootEntry); treeNode != NULL; treeNode = nextNode) {\r
 -                      nextNode = RB_NEXT(_Rm_AllocatorResourceTree, treeRootEntry, treeNode);\r
 -                      RB_REMOVE(_Rm_AllocatorResourceTree, treeRootEntry, nextNode);\r
 -                rmResourceNodeFree(treeNode);\r
 -              }\r
 -            Rm_osalFree((void *)treeRootEntry, sizeof(Rm_ResourceTree));\r
 -            allocatorDelete(rmInst, allocator->resourceName);\r
 -            return (RM_ERROR_GRL_RES_SPECIFIED_MORE_THAN_ONCE);\r
 -        }\r
 -        range = range->nextRange;\r
 -    }\r
 -    \r
 -    allocator->allocatorRootEntry = treeRootEntry;\r
 -    return(RM_OK);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Preallocates a resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Called when an allocate request is made but the base \r
 - *              is unspecified.  The preallocation algorithm looks at \r
 - *              available resources as well as policy permissions to \r
 - *              determine a resource range that satisfies the request.\r
 - *              If a valid range is found it will be returned for the \r
 - *              treeAllocate algorithm to handle.\r
 - */\r
 -static int32_t treePreAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourcePolicy,\r
 -                               Rm_AllocatorOpInfo *opInfo)\r
 -{\r
 -    Rm_ResourceNode    findNode;\r
 -    Rm_ResourceNode   *matchingNode = NULL;\r
 -    uint32_t           matchingEnd;\r
 -    uint32_t           rangeIndex;\r
 -    bool               resourceFound = false;\r
 -    Rm_PolicyCheckType policyCheckType;\r
 -    Rm_PolicyCheckCfg  policyCheckCfg;\r
 -    bool               nodePassesPolicy;\r
 -    int32_t            retVal = RM_SERVICE_PROCESSING;    \r
 -\r
 -    opInfo->resourceInfo->base = rmPolicyGetResourceBase(rmInst->policy, opInfo->serviceSrcInstNode, \r
 -                                                          resourcePolicy, opInfo->allocType, \r
 -                                                          &retVal);\r
 -    if (retVal != RM_SERVICE_PROCESSING) {\r
 -        return (retVal);\r
 -    }\r
 -\r
 -    if (opInfo->resourceInfo->alignment == RM_RESOURCE_ALIGNMENT_UNSPECIFIED) {  \r
 -        /* Get alignment from policy */\r
 -        opInfo->resourceInfo->alignment = rmPolicyGetResourceAlignment(rmInst->policy, resourcePolicy);\r
 -    }\r
 -    \r
 -    if (opInfo->resourceInfo->alignment == 0) {\r
 -        opInfo->resourceInfo->alignment = 1;\r
 -    }    \r
 -\r
 -    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));\r
 -    findNode.base = opInfo->resourceInfo->base;\r
 -    findNode.length = opInfo->resourceInfo->length;\r
 -\r
 -    /* Configure policy checking structure */\r
 -    memset((void *)&policyCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));\r
 -    if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_INIT_SHIFT)) {\r
 -        policyCheckType = Rm_policyCheck_INIT;\r
 -    }\r
 -    else if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_USE_SHIFT)) {\r
 -        policyCheckType = Rm_policyCheck_USE;\r
 -    }\r
 -    policyCheckCfg.policyDtb = rmInst->policy;\r
 -    policyCheckCfg.resourceOffset = resourcePolicy;\r
 -    \r
 -    do {\r
 -        matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);\r
 -        \r
 -        if (matchingNode) {\r
 -            nodePassesPolicy = false;\r
 -            policyCheckCfg.type = policyCheckType;\r
 -            policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;\r
 -            policyCheckCfg.resourceBase = findNode.base;\r
 -            policyCheckCfg.resourceLength = findNode.length;\r
 -            nodePassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);    \r
 -            \r
 -            if (nodePassesPolicy && (matchingNode->allocationCount > 0)) {\r
 -                /* Check exclusive privileges of instance requesting resource.  Requesting\r
 -                 * instance with exclusive privileges can't reserve resource if already owned*/\r
 -                policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;\r
 -                policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;\r
 -                nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);\r
 -            }\r
 -            \r
 -            if (nodePassesPolicy && (matchingNode->allocationCount == 1)) {\r
 -                /* Check exclusive privileges of instance that currently owns resource */\r
 -                policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;\r
 -                policyCheckCfg.validInstNode = matchingNode->ownerList->instNameNode;\r
 -                nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);\r
 -            }\r
 -\r
 -            if (retVal != RM_SERVICE_PROCESSING) {\r
 -                break;\r
 -            }\r
 -\r
 -            if (nodePassesPolicy) {\r
 -                matchingEnd = matchingNode->base + matchingNode->length - 1;\r
 -                /* Initialize indexer to be first resource value that alignment */\r
 -                rangeIndex = findNode.base;\r
 -                if (rangeIndex % opInfo->resourceInfo->alignment) {\r
 -                    rangeIndex += (opInfo->resourceInfo->alignment -\r
 -                                  (rangeIndex % opInfo->resourceInfo->alignment));\r
 -                }\r
 -                \r
 -                if ((rangeIndex + opInfo->resourceInfo->length - 1) <= matchingEnd) {\r
 -                    /* Block of unallocated resources within matchingNode that satisfies\r
 -                     * allocate requirements */\r
 -                    opInfo->resourceInfo->base = rangeIndex;\r
 -                    resourceFound = true;\r
 -                }     \r
 -            }\r
 -            \r
 -            if (!resourceFound) {\r
 -                /* Check next resource node for available resources */\r
 -                findNode.base = matchingNode->base + matchingNode->length;\r
 -            }\r
 -        }\r
 -        else {\r
 -            retVal = RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET;\r
 -        }\r
 -    } while ((!resourceFound) && \r
 -             (retVal != RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET));\r
 -\r
 -    return(retVal); \r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Allocates a resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Will attempt to allocate the resource with specified\r
 - *              base and length from the resource's allocator.  The\r
 - *              allocation algorithm will verify the allocation against\r
 - *              the policy permissions for the instance requesting the\r
 - *              allocation.  If the policy allows the allocation the \r
 - *              algorithm will allocate the resource then combine any\r
 - *              resource nodes that may have become equivalent (in terms\r
 - *              of ownership) after the allocation.\r
 - */\r
 -static int32_t treeAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourcePolicy,\r
 -                            Rm_AllocatorOpInfo *opInfo)\r
 -{\r
 -    Rm_ResourceNode     findNode;\r
 -    Rm_ResourceNode    *matchingNode = NULL;\r
 -    Rm_ResourceNode    *leftNode = NULL;\r
 -    Rm_ResourceNode    *rightNode = NULL;\r
 -    Rm_PolicyCheckType  policyCheckType;    \r
 -    Rm_PolicyCheckCfg   policyCheckCfg;\r
 -    bool                allocPassesPolicy;\r
 -    bool                combineLeft = false;\r
 -    bool                combineRight = false;    \r
 -    uint32_t            findEnd;\r
 -    uint32_t            matchingEnd;  \r
 -    int32_t             retVal = RM_SERVICE_PROCESSING;\r
 -\r
 -    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));\r
 -    findNode.base = opInfo->resourceInfo->base;\r
 -    findNode.length = opInfo->resourceInfo->length;\r
 -    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);\r
 -\r
 -    /* Prepare privilege checks */\r
 -    memset((void *)&policyCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));\r
 -    if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_INIT_SHIFT)) {\r
 -        policyCheckType = Rm_policyCheck_INIT;\r
 -    }\r
 -    else if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_USE_SHIFT)) {\r
 -        policyCheckType = Rm_policyCheck_USE;\r
 -    }\r
 -\r
 -    if (matchingNode) {\r
 -        findEnd = findNode.base + findNode.length - 1;\r
 -        matchingEnd = matchingNode->base + matchingNode->length - 1;\r
 -        \r
 -        if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {\r
 -            if (opInfo->serviceSrcInstNode == rmPolicyGetLinuxInstNode(rmInst->validInstances)) {\r
 -                /* Bypass policy checks since Linux Kernel has full privileges */\r
 -                allocPassesPolicy = true;\r
 -            }\r
 -            else {\r
 -                policyCheckCfg.policyDtb = rmInst->policy;\r
 -                policyCheckCfg.resourceOffset = resourcePolicy;    \r
 -                policyCheckCfg.type = policyCheckType;\r
 -                policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;\r
 -                policyCheckCfg.resourceBase = findNode.base;\r
 -                policyCheckCfg.resourceLength = findNode.length;\r
 -                allocPassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);\r
 -                if (!allocPassesPolicy) {\r
 -                    if (policyCheckType == Rm_policyCheck_INIT) {\r
 -                        retVal = RM_SERVICE_DENIED_INIT_PERM_NOT_GIVEN;\r
 -                    }\r
 -                    else {\r
 -                        retVal = RM_SERVICE_DENIED_USE_PERM_NOT_GIVEN;\r
 -                    }\r
 -                }\r
 -\r
 -                if (!isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {\r
 -                    /* Perform exclusive checks if requesting instance does not already an\r
 -                     * owner of the resource */\r
 -                    if (allocPassesPolicy && (matchingNode->allocationCount > 0)) {\r
 -                        /* Check exclusive privileges of instance requesting resource.  Requesting\r
 -                         * instance with exclusive privileges can't reserve resource if already owned*/\r
 -                        policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;\r
 -                        policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;\r
 -                        allocPassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);\r
 -                        if (!allocPassesPolicy) {\r
 -                            retVal = RM_SERVICE_DENIED_EXCLUSIVE_RES_ALLOCD;\r
 -                        }\r
 -                    }\r
 -                    if (allocPassesPolicy && (matchingNode->allocationCount == 1)) {\r
 -                        /* Check exclusive privileges of instance that currently owns resource */\r
 -                        policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;\r
 -                        policyCheckCfg.validInstNode = matchingNode->ownerList->instNameNode;\r
 -                        allocPassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);\r
 -                        if (!allocPassesPolicy) {\r
 -                            retVal = RM_SERVICE_DENIED_ALLOCD_TO_EXCLUSIVE_INST;\r
 -                        }                \r
 -                    }  \r
 -                }\r
 -            }\r
 -            \r
 -            if (allocPassesPolicy) {\r
 -                if (!isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {\r
 -                    /* Handle any possible node combinations if requesting instance is\r
 -                     * not already in resource's owner list.  Automatic approval if requesting\r
 -                     * instance is already in owner list. */\r
 -                    if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd)) {\r
 -                        /* findNode range matches matchingNode range\r
 -                         *\r
 -                         *   |<--left node-->||<--matched  node-->||<--right node-->| => existing node\r
 -                         *                    |<--alloc request-->|  => requested resources\r
 -                         */                     \r
 -                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        addOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -\r
 -                        if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                            combineLeft = true;\r
 -                        }\r
 -                        if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                            combineRight = true;\r
 -                        }\r
 -\r
 -                        if (combineLeft && combineRight) {\r
 -                            /* Combine all three nodes into matchingNode */\r
 -                            matchingNode->base = leftNode->base;\r
 -                            matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;\r
 -\r
 -                            clearOwners(leftNode);\r
 -                            rmResourceNodeFree(leftNode);\r
 -                            clearOwners(rightNode);\r
 -                            rmResourceNodeFree(rightNode);                        \r
 -                        }\r
 -                        else if (combineLeft) {\r
 -                            /* Combine left and matching nodes.  Reinsert right. */\r
 -                            matchingNode->base = leftNode->base;\r
 -                            matchingNode->length += leftNode->length;\r
 -\r
 -                            clearOwners(leftNode);\r
 -                            rmResourceNodeFree(leftNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);                        \r
 -                        }\r
 -                        else if (combineRight) {\r
 -                            /* Combine right and matching nodes.  Reinsert left. */\r
 -                            matchingNode->length += rightNode->length;\r
 -\r
 -                            clearOwners(rightNode);\r
 -                            rmResourceNodeFree(rightNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        }\r
 -                        else {\r
 -                            /* No combine. */\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                        }\r
 -\r
 -                        /* Always reinsert matchingNode */                \r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);   \r
 -                    }   \r
 -                    else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {\r
 -                        /* findNode range is subset of matchingNode range and neither boundary is\r
 -                         * equivalent.\r
 -                         *\r
 -                         * |<----------matched node---------->|\r
 -                         *        |<---alloc request--->|\r
 -                         */ \r
 -                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);\r
 -                        copyOwners(leftNode, matchingNode);\r
 -                        rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);\r
 -                        copyOwners(rightNode, matchingNode);\r
 -\r
 -                        matchingNode->base = findNode.base;                                    \r
 -                        matchingNode->length = findNode.length;\r
 -                        addOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -\r
 -                        /* Insert all the nodes */\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                    }  \r
 -                    else {    \r
 -                        if (findNode.base == matchingNode->base) {\r
 -                            /* findNode base and matchingNode base are equivalent.  May be combine\r
 -                             * possibilities to the left\r
 -                             *\r
 -                             * |<---left node (alloc'd)--->||<----------matched node---------->|\r
 -                             *                              |<---findNode (alloc req)--->|\r
 -                             */                         \r
 -                            leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            /* Add allocating instance to owner list for compare with leftNode */\r
 -                            addOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                            \r
 -                            if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {\r
 -                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                                /* Combine leftNode and findNode */\r
 -                                leftNode->length += findNode.length;\r
 -                            }\r
 -                            else {\r
 -                                leftNode = rmResourceNodeNew(findNode.base, findNode.length);\r
 -                                copyOwners(leftNode, matchingNode);\r
 -                            }\r
 -\r
 -                            /* Account for leftNode in matchingNode */\r
 -                            matchingNode->base = findNode.base + findNode.length;\r
 -                            matchingNode->length = matchingEnd - findEnd;  \r
 -\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        }\r
 -                        else if (findEnd == matchingEnd) {\r
 -                            /* findNode end and matchingNode end are equivalent.  May be combine\r
 -                             * possibilities to the right\r
 -                             *\r
 -                             * |<----------matched node---------->||<---right node (alloc'd)--->|\r
 -                             *       |<---findNode (alloc req)--->| \r
 -                             */                        \r
 -                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            /* Add allocating instance to owner list for compare with rightNode */\r
 -                            addOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                            \r
 -                            if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {\r
 -                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                                /* Combine rightNode and findNode */\r
 -                                rightNode->base = findNode.base;\r
 -                                rightNode->length += findNode.length;\r
 -                            }\r
 -                            else {\r
 -                                rightNode = rmResourceNodeNew(findNode.base, findNode.length);\r
 -                                copyOwners(rightNode, matchingNode);\r
 -                            }\r
 -\r
 -                            /* Account for rightNode in matchingNode */\r
 -                            matchingNode->length -= findNode.length;  \r
 -\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                        }\r
 -                        /* Remove allocating instance from leftover matchingNode */\r
 -                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                    }\r
 -                }\r
 -                retVal = RM_SERVICE_APPROVED;\r
 -            }\r
 -        }\r
 -        else {\r
 -            retVal = RM_SERVICE_DENIED_PARTIAL_ALLOCATION;\r
 -        }\r
 -    }\r
 -    else {\r
 -        retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;\r
 -    }\r
 -\r
 -    return(retVal);        \r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Frees a resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Will attempt to free the resource with specified\r
 - *              base and length from the resource's allocator.  The\r
 - *              free algorithm will verify the free request parameters\r
 - *              match an allocated range for the resource and that the\r
 - *              range is owned by the instance requesting the free. If\r
 - *              the free is validated the algorithm will free the \r
 - *              resource then combine any resource nodes that may have\r
 - *              become equivalent (in terms of ownership) after the\r
 - *              allocation.\r
 - */\r
 -static int32_t treeFree(Rm_Allocator *allocator, Rm_AllocatorOpInfo *opInfo)\r
 -{\r
 -    Rm_ResourceNode  findNode;\r
 -    Rm_ResourceNode *matchingNode = NULL;\r
 -    Rm_ResourceNode *leftNode = NULL;\r
 -    Rm_ResourceNode *rightNode = NULL;\r
 -    bool             combineLeft = false;\r
 -    bool             combineRight = false;\r
 -    uint32_t         findEnd;\r
 -    uint32_t         matchingEnd;\r
 -    int32_t          retVal;\r
 -\r
 -    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));\r
 -    findNode.base = opInfo->resourceInfo->base;\r
 -    findNode.length = opInfo->resourceInfo->length;\r
 -    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);\r
 -\r
 -    if (matchingNode) {\r
 -        findEnd = findNode.base + findNode.length - 1;\r
 -        matchingEnd = matchingNode->base + matchingNode->length - 1;\r
 -        \r
 -        if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {  \r
 -            if (matchingNode->allocationCount) {\r
 -                if (isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {\r
 -                    if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd))\r
 -                    {\r
 -                        /* Case 1: Free range equals allocated matched node exactly. Attempt to combine \r
 -                         *         freed node with nodes to left and right.\r
 -                         *\r
 -                         * |<--left node-->||<---matched node--->||<--right node-->|\r
 -                         *                  |<---free request--->|\r
 -                         */ \r
 -                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -\r
 -                        if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                            combineLeft = true;\r
 -                        }\r
 -                        if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                            combineRight = true;\r
 -                        }\r
 -\r
 -                        if (combineLeft && combineRight) {\r
 -                            /* Combine all three nodes into matchingNode */\r
 -                            matchingNode->base = leftNode->base;\r
 -                            matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;\r
 -\r
 -                            clearOwners(leftNode);\r
 -                            rmResourceNodeFree(leftNode);\r
 -                            clearOwners(rightNode);\r
 -                            rmResourceNodeFree(rightNode);                        \r
 -                        }\r
 -                        else if (combineLeft) {\r
 -                            /* Combine left and matching nodes.  Reinsert right. */\r
 -                            matchingNode->base = leftNode->base;\r
 -                            matchingNode->length += leftNode->length;\r
 -\r
 -                            clearOwners(leftNode);\r
 -                            rmResourceNodeFree(leftNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);                        \r
 -                        }\r
 -                        else if (combineRight) {\r
 -                            /* Combine right and matching nodes.  Reinsert left. */\r
 -                            matchingNode->length += rightNode->length;\r
 -\r
 -                            clearOwners(rightNode);\r
 -                            rmResourceNodeFree(rightNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        }\r
 -                        else {\r
 -                            /* No combine. */\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                        }\r
 -\r
 -                        /* Always reinsert matchingNode */\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);                    \r
 -                    }\r
 -                    else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {\r
 -                        /* Case 2: Free range is less than range in matched node. Split\r
 -                         *         matched node into three nodes.\r
 -                         *\r
 -                         * |<----------matched node---------->|\r
 -                         *        |<---free request--->|\r
 -                         *\r
 -                         * Remove instance from AllocatedTo list then add it back in for side nodes for\r
 -                         * proper accounting of allocations in validInstance list\r
 -                         */ \r
 -                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                        \r
 -                        leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);\r
 -                        copyOwners(leftNode, matchingNode);\r
 -                        addOwner(leftNode, opInfo->serviceSrcInstNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        \r
 -                        rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);\r
 -                        copyOwners(rightNode, matchingNode);\r
 -                        addOwner(rightNode, opInfo->serviceSrcInstNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -\r
 -                        matchingNode->base = findNode.base;                                    \r
 -                        matchingNode->length = findNode.length;\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                    }\r
 -                    else {                        \r
 -                        if (findNode.base == matchingNode->base) {\r
 -                            /* Case 3: Free range is on left boundary of matched node. Try to \r
 -                             *         combine free range with left node.\r
 -                             *\r
 -                             * |<---left node (free)--->||<----------matched node---------->|\r
 -                             *                           |<---findNode (free req)--->|\r
 -                             */ \r
 -\r
 -                            leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            /* Remove freeing instance from owner list for compare with leftNode */\r
 -                            deleteOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                            \r
 -                            if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {\r
 -                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                                /* Combine leftNode and findNode */\r
 -                                leftNode->length += findNode.length;\r
 -                            }\r
 -                            else {\r
 -                                leftNode = rmResourceNodeNew(findNode.base, findNode.length);\r
 -                                copyOwners(leftNode, matchingNode);\r
 -                            }\r
 -\r
 -                            /* Remove leftNode range from matchingNode */\r
 -                            matchingNode->base = findNode.base + findNode.length;\r
 -                            matchingNode->length = matchingEnd - findEnd;  \r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);\r
 -                        }\r
 -                        else if (findEnd == matchingEnd) {\r
 -                            /* Case 4: Free range is on right boundary of matched node. Try to \r
 -                             *         combine free range with right node.\r
 -                             *\r
 -                             * |<----------matched node---------->||<---right node (free)--->|\r
 -                             *        |<---findNode (free req)--->|\r
 -                             */ \r
 -                            \r
 -                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode); \r
 -                            /* Remove freeing instance from owner list for compare with rightNode */\r
 -                            deleteOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                            \r
 -                            if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {\r
 -                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                                /* Combine rightNode and findNode */\r
 -                                rightNode->base = findNode.base;\r
 -                                rightNode->length += findNode.length;\r
 -                            }\r
 -                            else {\r
 -                                rightNode = rmResourceNodeNew(findNode.base, findNode.length);\r
 -                                copyOwners(rightNode, matchingNode);\r
 -                            }\r
 -\r
 -                            /* Remove rightNode range from matchingNode */\r
 -                            matchingNode->length -= findNode.length;  \r
 -                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);\r
 -                        }\r
 -\r
 -                        /* Add freeing instance back into matchingNode allocations */\r
 -                        addOwner(matchingNode, opInfo->serviceSrcInstNode);\r
 -                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);\r
 -                    }\r
 -\r
 -                    retVal = RM_SERVICE_APPROVED;\r
 -                }\r
 -                else {\r
 -                    retVal = RM_SERVICE_DENIED_RES_NOT_ALLOCD_TO_INST;\r
 -                }\r
 -            }\r
 -            else {\r
 -                retVal = RM_SERVICE_DENIED_RES_ALREADY_FREE;\r
 -            }\r
 -        }\r
 -        else {\r
 -            retVal = RM_SERVICE_DENIED_PARTIAL_FREE;\r
 -        }\r
 -    }\r
 -    else {\r
 -        retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;\r
 -    }\r
 -    return(retVal);  \r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Issues a service response to application\r
 - ***********************************************************************\r
 - * DESCRIPTION: Provides a service response back to the application\r
 - *              using the service callback function provided to\r
 - *              the RM instance at the time of the service request.\r
 - */\r
 -static void serviceResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 -{\r
 -    Rm_ServiceRespInfo serviceResponse;\r
 -\r
 -    /* The responseTransaction will contain the resultant state details of\r
 -     * the requestTransaction's service request */\r
 -    serviceResponse.serviceState = transaction->state;\r
 -    /* Pass back the ID that was provided to the component when it requested\r
 -     * the service */\r
 -    serviceResponse.serviceId = transaction->localId;\r
 -\r
 -    /* Service was approved and service was an allocate request.  The resource\r
 -     * data is passed back to the component */\r
 -    if ((serviceResponse.serviceState == RM_SERVICE_APPROVED) &&\r
 -        ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||\r
 -         (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||\r
 -         (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))\r
 -    {\r
 -        strncpy(serviceResponse.resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);\r
 -        serviceResponse.resourceBase = transaction->resourceInfo.base;\r
 -        serviceResponse.resourceLength = transaction->resourceInfo.length;\r
 -    }\r
 -\r
 -    /* Issue the callback to the requesting component with the response information */\r
 -    transaction->callback.serviceCallback(&serviceResponse);\r
 -\r
 -    /* Delete the transaction from the transaction queue */\r
 -    rmTransactionQueueDelete(rmInst, transaction->localId);\r
 -    return;\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Sends RM response packets\r
 - ***********************************************************************\r
 - * DESCRIPTION: Sends RM response packets to RM instance's that sent\r
 - *              RM request packets to the RM instance.  The response\r
 - *              is sent via the RM transport API which is plugged\r
 - *              with an application created transport path.\r
 - */\r
 -static void transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 -{\r
 -    Rm_Transport    *dstTransport = NULL;\r
 -    Rm_PacketHandle  pktHandle = NULL;\r
 -\r
 -    dstTransport = rmTransportFindRemoteName((Rm_Transport *) rmInst->transports, transaction->pktSrcInstName);\r
 -\r
 -    switch (transaction->type) {\r
 -        case Rm_service_RESOURCE_ALLOCATE_INIT:\r
 -        case Rm_service_RESOURCE_ALLOCATE_USE:\r
 -        case Rm_service_RESOURCE_FREE:\r
 -        case Rm_service_RESOURCE_GET_BY_NAME:\r
 -            pktHandle = rmTransportCreateResourceResponsePkt(rmInst, dstTransport->appTransportHandle, \r
 -                                                             transaction);\r
 -            break;\r
 -        case Rm_service_RESOURCE_MAP_TO_NAME:\r
 -        case Rm_service_RESOURCE_UNMAP_NAME:\r
 -            pktHandle = rmTransportCreateNsResponsePkt(rmInst, dstTransport->appTransportHandle,\r
 -                                                       transaction);\r
 -            break;\r
 -    }\r
 -\r
 -    if (pktHandle) {\r
 -        if (rmInst->transportCallouts.rmSendPkt) {\r
 -            if (rmInst->transportCallouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {\r
 -                transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;\r
 -            }\r
 -        }\r
 -        else {\r
 -            transaction->state = RM_ERROR_TRANSPORT_SEND_NOT_REGD;\r
 -        }\r
 -    }\r
 -    rmTransactionQueueDelete(rmInst, transaction->localId);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Sends RM request packets\r
 - ***********************************************************************\r
 - * DESCRIPTION: Sends RM request packets to RM instance's that are\r
 - *              capable of forwarding or validating service requests.\r
 - *              The request is sent via the RM transport API which is\r
 - *              plugged with an application created transport path.\r
 - */\r
 -static void transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 -{\r
 -    Rm_Transport    *dstTransport = NULL;\r
 -    Rm_PacketHandle  pktHandle = NULL;\r
 -\r
 -    if (rmInst->registeredWithDelegateOrServer) {\r
 -        if (rmInst->instType == Rm_instType_CLIENT) {\r
 -            dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_CLIENT_DELEGATE);\r
 -\r
 -            if (!dstTransport) {\r
 -                dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_SERVER);\r
 -            }\r
 -        } \r
 -        else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {\r
 -            dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_SERVER);\r
 -        }\r
 -\r
 -        switch (transaction->type) {\r
 -            case Rm_service_RESOURCE_ALLOCATE_INIT:\r
 -            case Rm_service_RESOURCE_ALLOCATE_USE:\r
 -            case Rm_service_RESOURCE_FREE:\r
 -            case Rm_service_RESOURCE_GET_BY_NAME:\r
 -                pktHandle = rmTransportCreateResourceReqPkt(rmInst, dstTransport->appTransportHandle, transaction);\r
 -                break;\r
 -            case Rm_service_RESOURCE_MAP_TO_NAME:\r
 -            case Rm_service_RESOURCE_UNMAP_NAME:\r
 -                pktHandle = rmTransportCreateNsRequestPkt(rmInst, dstTransport->appTransportHandle, transaction);\r
 -                break;\r
 -        }\r
 -\r
 -        if (pktHandle) {\r
 -            if (rmInst->transportCallouts.rmSendPkt) {            \r
 -                if (rmInst->transportCallouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {\r
 -                    transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;\r
 -                }\r
 -            }\r
 -            else {\r
 -                transaction->state = RM_ERROR_TRANSPORT_SEND_NOT_REGD;\r
 -            }                \r
 -        }\r
 -\r
 -        transaction->hasBeenForwarded = true;\r
 -        /* Transaction not deleted.  Waiting for response from RM CD or Server */\r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Issues an allocator operation\r
 - ***********************************************************************\r
 - * DESCRIPTION: Issues an allocator preallocate, allocate, or free\r
 - *              for an RM resource.\r
 - */\r
 -static int32_t allocatorOperation(Rm_Inst *rmInst, Rm_AllocatorOpInfo *opInfo)\r
 -{\r
 -    Rm_Allocator *allocator = NULL;\r
 -    int32_t       resourceOffsetInPolicy;\r
 -    int32_t       retVal;\r
 -    \r
 -    resourceOffsetInPolicy = rmPolicyGetResourceOffset(rmInst->policy, opInfo->resourceInfo->name);\r
 -    allocator = rmAllocatorFind(rmInst->allocators, opInfo->resourceInfo->name);\r
 -    \r
 -    if ((resourceOffsetInPolicy > 0) && allocator) {\r
 -        if (opInfo->operation == Rm_allocatorOp_PRE_ALLOCATE) {\r
 -            retVal = treePreAllocate(rmInst, allocator, resourceOffsetInPolicy, opInfo);\r
 -        }               \r
 -        else if (opInfo->operation == Rm_allocatorOp_ALLOCATE) {\r
 -            retVal = treeAllocate(rmInst, allocator, resourceOffsetInPolicy, opInfo);\r
 -        }\r
 -        else if (opInfo->operation == Rm_allocatorOp_FREE) {\r
 -            retVal = treeFree(allocator, opInfo);\r
 -        }         \r
 -    }\r
 -    else {\r
 -        /* Resource could not be found in policy and/or allocator */\r
 -        retVal = RM_SERVICE_DENIED_RES_DOES_NOT_EXIST;\r
 -    }\r
 -    return(retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Arbitrates allocation service requests\r
 - ***********************************************************************\r
 - * DESCRIPTION: Issues a set of allocator operations in order to\r
 - *              handle a received allocation request.  Allocation\r
 - *              requests are always forwarded to the Server on Client\r
 - *              CD instances.  If a request is made with a NameServer\r
 - *              name the resource base and length parameters are\r
 - *              retrieved from the NameServer prior to the allocation\r
 - *              attempt.\r
 - */\r
 -static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *validInstNode,\r
 -                               uint32_t allocType)\r
 -{\r
 -    Rm_AllocatorOpInfo  opInfo;\r
 -    Rm_NameServerObjCfg nameServerObjCfg;\r
 -    int32_t             retVal = transaction->state;\r
 -\r
 -    memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));\r
 -    \r
 -    if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {\r
 -        /* Forward all allocation requests to Server if transport is up.  Otherwise, just queue. */\r
 -        if (rmInst->registeredWithDelegateOrServer) {\r
 -            transactionForwarder(rmInst, transaction);   \r
 -        }  \r
 -    }\r
 -    else if (rmInst->instType == Rm_instType_SERVER) {\r
 -        opInfo.resourceInfo = &transaction->resourceInfo;\r
 -        opInfo.serviceSrcInstNode = validInstNode;\r
 -        opInfo.allocType = allocType;\r
 -\r
 -        /* Populated NameServer name has precedence over base */\r
 -        if (strlen(transaction->resourceInfo.nameServerName) > 0) {\r
 -            if ((transaction->resourceInfo.base == 0) &&\r
 -                (transaction->resourceInfo.length == 0) &&\r
 -                (transaction->resourceInfo.alignment == 0)) {\r
 -                memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));\r
 -                nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
 -                nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;\r
 -                if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {\r
 -                    strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
 -                    transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
 -                    transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
 -                }                \r
 -            }\r
 -            else {\r
 -                retVal = RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT;\r
 -            }\r
 -        }\r
 -\r
 -        if (retVal == RM_SERVICE_PROCESSING) {      \r
 -            if (transaction->resourceInfo.base == RM_RESOURCE_BASE_UNSPECIFIED) {\r
 -                opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE;\r
 -                retVal = allocatorOperation(rmInst, &opInfo);\r
 -            }\r
 -        \r
 -            if (retVal == RM_SERVICE_PROCESSING) {\r
 -                opInfo.operation = Rm_allocatorOp_ALLOCATE;\r
 -                retVal = allocatorOperation(rmInst, &opInfo);\r
 -            }      \r
 -        }\r
 -        \r
 -        transaction->state = retVal;\r
 -\r
 -        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -            /* Source of allocation was not the server instance, provide the transaction\r
 -             * to the transaction responder */\r
 -            transactionResponder(rmInst, transaction);\r
 -        }\r
 -        /* Otherwise let the return stack return the transaction to the serviceHandler */                   \r
 -    }   \r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Arbitrates free service requests\r
 - ***********************************************************************\r
 - * DESCRIPTION: Issues a set of allocator operations in order to\r
 - *              handle a received free request.  Free\r
 - *              requests are always forwarded to the Server on Client\r
 - *              CD instances.  If a request is made with a NameServer\r
 - *              name the resource base and length parameters are\r
 - *              retrieved from the NameServer prior to the free\r
 - *              attempt.\r
 - */\r
 -static void freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *validInstNode)\r
 -{\r
 -    Rm_AllocatorOpInfo  opInfo; \r
 -    Rm_NameServerObjCfg nameServerObjCfg;    \r
 -    int32_t             retVal = transaction->state;\r
 -\r
 -    memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));\r
 -    \r
 -    if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {\r
 -        /* Forward all free requests to Server if transport is up.  Otherwise, just queue. */\r
 -        if (rmInst->registeredWithDelegateOrServer) {\r
 -            transactionForwarder(rmInst, transaction);   \r
 -        }\r
 -    }\r
 -    else if (rmInst->instType == Rm_instType_SERVER) {\r
 -        opInfo.resourceInfo = &transaction->resourceInfo;\r
 -        opInfo.serviceSrcInstNode = validInstNode;\r
 -\r
 -        /* Populated NameServer name has precedence over base */\r
 -        if (strlen(transaction->resourceInfo.nameServerName) > 0) {\r
 -            if ((transaction->resourceInfo.base == 0) &&\r
 -                (transaction->resourceInfo.length == 0) &&\r
 -                (transaction->resourceInfo.alignment == 0)) {\r
 -                memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));\r
 -                nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
 -                nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;\r
 -                if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {\r
 -                    strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
 -                    transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
 -                    transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
 -                } \r
 -            }\r
 -            else {\r
 -                retVal = RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT;\r
 -            }                \r
 -        }\r
 -        \r
 -        if(retVal == RM_SERVICE_PROCESSING) {        \r
 -            opInfo.operation = Rm_allocatorOp_FREE;\r
 -            retVal = allocatorOperation(rmInst, &opInfo);\r
 -        }       \r
 -\r
 -        transaction->state = retVal;\r
 -\r
 -        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -            /* Source of allocation was not the server instance, provide the transaction\r
 -             * to the transaction responder */\r
 -            transactionResponder(rmInst, transaction);\r
 -        }\r
 -        /* Otherwise let the return stack return the transaction to the serviceHandler */        \r
 -    }   \r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Reserves a Linux resource\r
 - ***********************************************************************\r
 - * DESCRIPTION: Reserves resources for Linux using the base and length\r
 - *              values retrieved from the Linux DTB via the\r
 - *              "linux-dtb-alias" properties within the GRL.\r
 - */\r
 -static int32_t reserveLinuxResource(Rm_Inst *rmInst, Rm_LinuxAlias *linuxAlias, \r
 -                                    Rm_LinuxValueRange *linuxValues, Rm_AllocatorOpInfo *opInfo)\r
 -{\r
 -    int32_t  retVal = RM_OK;\r
 -    bool     baseFound = false;\r
 -    bool     lengthFound = false;\r
 -    uint32_t valueIndex = 0;\r
 -\r
 -    while ((linuxValues) && (!baseFound || !lengthFound)) {\r
 -        if (linuxAlias->baseOffset == valueIndex) {\r
 -            opInfo->resourceInfo->base = linuxValues->value;\r
 -            baseFound = true;\r
 -\r
 -            if (linuxAlias->lengthOffset == RM_DTB_UTIL_LINUX_ALIAS_OFFSET_NOT_SET) {\r
 -                opInfo->resourceInfo->length = 1;\r
 -                lengthFound = true;\r
 -            }\r
 -        }\r
 -        else if (linuxAlias->lengthOffset == valueIndex) {\r
 -            opInfo->resourceInfo->length = linuxValues->value;\r
 -            lengthFound = true;\r
 -        }\r
 -\r
 -        linuxValues = (Rm_LinuxValueRange *)linuxValues->nextValue;\r
 -        valueIndex++;\r
 -    }\r
 -\r
 -    if (!baseFound || !lengthFound) {\r
 -        retVal = RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS;\r
 -    }\r
 -    else {\r
 -        /* Allocate resource to Linux */\r
 -        retVal = allocatorOperation(rmInst, opInfo);\r
 -    }\r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Finds and reserves Linux resources\r
 - ***********************************************************************\r
 - * DESCRIPTION: Parses the Linux DTB for resources consumed by the\r
 - *              Linux kernel.  If the resource is found via the\r
 - *              "linux-dtb-alias" property defined in the GRL it is \r
 - *              reserved.\r
 - */\r
 -static int32_t findAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName, void *linuxDtb, \r
 -                                           Rm_LinuxAlias *linuxAlias)\r
 -{\r
 -    Rm_AllocatorOpInfo  opInfo;\r
 -    Rm_ResourceInfo     resourceInfo;\r
 -    uint32_t            pathOffset;\r
 -    uint32_t            pathSize;\r
 -    char               *spacePtr;\r
 -    int32_t             propOffset;\r
 -    int32_t             nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;\r
 -    int32_t             prevDepth = RM_DTB_UTIL_STARTING_DEPTH;\r
 -    int32_t             depth;\r
 -    int32_t             propertyLen;\r
 -    const char         *propertyName;\r
 -    const void         *propertyData; \r
 -    Rm_LinuxValueRange *linuxValueRange;\r
 -    int32_t             retVal = RM_OK; \r
 -\r
 -    memset((void *) &opInfo, 0, sizeof(Rm_AllocatorOpInfo));\r
 -    memset((void *) &resourceInfo, 0, sizeof(Rm_ResourceInfo));\r
 -\r
 -    strncpy(resourceInfo.name, resourceName, RM_NAME_MAX_CHARS);\r
 -    opInfo.serviceSrcInstNode = rmPolicyGetLinuxInstNode(rmInst->validInstances);\r
 -    opInfo.operation = Rm_allocatorOp_ALLOCATE;\r
 -    opInfo.resourceInfo = &resourceInfo;    \r
 -\r
 -    while(linuxAlias) {\r
 -        /* Reset parsing variables */\r
 -        pathOffset = 0;\r
 -        pathSize = strlen(linuxAlias->path) + 1;\r
 -        nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;\r
 -        prevDepth = RM_DTB_UTIL_STARTING_DEPTH;   \r
 -        resourceInfo.base = 0;\r
 -        resourceInfo.length = 0;\r
 -\r
 -        spacePtr = strpbrk(linuxAlias->path, " ");\r
 -        if (spacePtr) {\r
 -            *spacePtr = '\0';\r
 -        }       \r
 -        \r
 -        while(pathOffset < pathSize) {\r
 -            /* Move through DTB nodes until next alias path node found */\r
 -            if (strcmp(linuxAlias->path + pathOffset, fdt_get_name(linuxDtb, nodeOffset, NULL))) {\r
 -                nodeOffset = fdt_next_node(linuxDtb, nodeOffset, &depth);\r
 -\r
 -                if ((depth < prevDepth) || (nodeOffset == -FDT_ERR_NOTFOUND)) {\r
 -                    /* Returning from subnode that matched part of alias path without finding\r
 -                     * resource values */\r
 -                    retVal = RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS;\r
 -                    break;\r
 -                }\r
 -            }\r
 -            else {\r
 -                /* Found next alias path node.  Move to next node name in path string. */\r
 -                pathOffset += (strlen(linuxAlias->path + pathOffset) + 1);\r
 -                spacePtr = strpbrk(linuxAlias->path + pathOffset, " ");\r
 -                if (spacePtr) {\r
 -                    *spacePtr = '\0';\r
 -                }       \r
 -                \r
 -                prevDepth = fdt_node_depth(linuxDtb, nodeOffset);\r
 -              propOffset = fdt_first_property_offset(linuxDtb, nodeOffset);\r
 -                while ((propOffset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) &&\r
 -                       (pathOffset < pathSize)) {\r
 -                    propertyData = fdt_getprop_by_offset(linuxDtb, propOffset, \r
 -                                                         &propertyName, &propertyLen);\r
 -\r
 -                    if (strcmp(linuxAlias->path + pathOffset, propertyName) == 0) {\r
 -                        /* Found resource at end of alias path */\r
 -                        pathOffset += (strlen(linuxAlias->path + pathOffset) + 1);\r
 -                        linuxValueRange = rmDtbUtilLinuxExtractValues(propertyData, propertyLen);\r
 -                        retVal = reserveLinuxResource(rmInst, linuxAlias, \r
 -                                                      linuxValueRange, &opInfo);\r
 -                        rmDtbUtilLinuxFreeValues(linuxValueRange);\r
 -                    }\r
 -                    propOffset = fdt_next_property_offset(linuxDtb, propOffset);\r
 -                } \r
 -\r
 -                if (propOffset < -FDT_ERR_NOTFOUND) {\r
 -                    retVal = propOffset;\r
 -                    break;\r
 -                }\r
 -            }\r
 -        }\r
 -\r
 -        if (retVal < RM_OK) {\r
 -            break;\r
 -        }\r
 -        linuxAlias = linuxAlias->nextLinuxAlias;\r
 -    }\r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Creates and initializes a resource allocator\r
 - ***********************************************************************\r
 - * DESCRIPTION: Creates a resource allocator for the provided\r
 - *              resource name and resource properties retrieved\r
 - *              from the GRL.  Resources will be reserved for \r
 - *              the Linux kernel if the Linux DTB is provided\r
 - *              and there are "linux-dtb-alias" properties\r
 - *              specified in the GRL.\r
 - */\r
 -static int32_t createAndInitAllocator(Rm_Inst *rmInst, const char *resourceName, \r
 -                                      Rm_ResourceProperties *resourceProperties, void *linuxDtb)\r
 -{\r
 -    Rm_ResourceRange    *range = NULL;\r
 -    Rm_ResourceRange    *rangeBasePtr = NULL;\r
 -    Rm_NsAssignment     *nsAssignments = NULL;\r
 -    Rm_NsAssignment     *nsAssignmentBasePtr = NULL;\r
 -    Rm_LinuxAlias       *linuxAlias = NULL;\r
 -    Rm_NameServerObjCfg  nameServerObjCfg;      \r
 -    int32_t              retVal = RM_OK;\r
 -\r
 -    if (resourceProperties->rangeData && (resourceProperties->rangeLen > 0)) {\r
 -        range = rangeBasePtr = rmDtbUtilResExtractRange(resourceProperties->rangeData, \r
 -                                                        resourceProperties->rangeLen);\r
 -        \r
 -        if ((retVal = createResourceTree(rmInst, resourceName, range)) >= RM_OK) {\r
 -            if (resourceProperties->linuxAliasData && resourceProperties->linuxAliasLen) {\r
 -                if (linuxDtb) {\r
 -                    linuxAlias = rmDtbUtilResExtractLinuxAlias(resourceProperties->linuxAliasData,\r
 -                                                               resourceProperties->linuxAliasLen, &retVal);\r
 -                    if (linuxAlias) {\r
 -                        retVal = findAndReserveLinuxResource(rmInst, resourceName, linuxDtb, linuxAlias);            \r
 -                    }\r
 -                }\r
 -                else {\r
 -                    retVal = RM_ERROR_GRL_LINUX_ALIAS_BUT_NO_DTB;\r
 -                }\r
 -            }\r
 -        }\r
 -    }\r
 -    \r
 -    if (retVal >= RM_OK) {\r
 -        if (resourceProperties->nsAssignData && resourceProperties->nsAssignLen) {\r
 -            nsAssignments = rmDtbUtilResExtractNsAssignment(resourceProperties->nsAssignData, \r
 -                                                            resourceProperties->nsAssignLen, &retVal);\r
 -            if (nsAssignments) {\r
 -                nsAssignmentBasePtr = nsAssignments;\r
 -                while (nsAssignments) {\r
 -                    memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));\r
 -                    nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
 -                    nameServerObjCfg.nodeCfg.objName = nsAssignments->nsName;\r
 -                    nameServerObjCfg.nodeCfg.resourceName = (char *)resourceName;\r
 -                    nameServerObjCfg.nodeCfg.resourceBase= nsAssignments->resourceBase;\r
 -                    nameServerObjCfg.nodeCfg.resourceLength = nsAssignments->resourceLength;                \r
 -                    rmNameServerAddObject(&nameServerObjCfg);\r
 -                    nsAssignments = nsAssignments->nextNsAssignment;\r
 -                }\r
 -                rmDtbUtilResFreeNsAssignmentList(nsAssignmentBasePtr);\r
 -            }\r
 -        }\r
 -    }\r
 -\r
 -    rmDtbUtilResFreeRange(rangeBasePtr);\r
 -    if (linuxAlias) {\r
 -        rmDtbUtilResFreeLinuxAlias(linuxAlias);\r
 -    }\r
 -    return(retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Recursively parses GRL resource properties\r
 - ***********************************************************************\r
 - * DESCRIPTION: Recursively parses and stores GRL resource node \r
 - *              properties using the LIBFDT APIs\r
 - */\r
 -static int32_t parseResourceProperty(void *globalResourceDtb, int32_t offset, \r
 -                                     Rm_ResourceProperties *propertyInfo)\r
 -{\r
 -      int32_t              propertyLen;\r
 -      const char          *propertyName;\r
 -      const void          *propertyData;\r
 -    Rm_ResourcePropType  propertyType;\r
 -    int32_t              retVal = RM_OK;\r
 -\r
 -      propertyData = fdt_getprop_by_offset(globalResourceDtb, offset, &propertyName, &propertyLen);\r
 -    propertyType = rmDtbUtilResGetPropertyType(propertyName);\r
 -    if (propertyType == Rm_resourcePropType_RESOURCE_RANGE) {\r
 -        propertyInfo->rangeData = propertyData;\r
 -        propertyInfo->rangeLen = propertyLen;\r
 -    }\r
 -    else if (propertyType == Rm_resourcePropType_NSASSIGNMENT) {\r
 -        propertyInfo->nsAssignData = propertyData;\r
 -        propertyInfo->nsAssignLen = propertyLen;\r
 -    }\r
 -    else if (propertyType == Rm_resourcePropType_RESOURCE_LINUX_ALIAS) {\r
 -        propertyInfo->linuxAliasData = propertyData;\r
 -        propertyInfo->linuxAliasLen = propertyLen;\r
 -    }        \r
 -    else {\r
 -        retVal = RM_ERROR_GRL_UNKNOWN_RESOURCE_PROPERTY;\r
 -    }\r
 -\r
 -    if (retVal == RM_OK) {\r
 -        offset = fdt_next_property_offset(globalResourceDtb, offset);\r
 -      if (offset >= 0) {\r
 -          retVal = parseResourceProperty(globalResourceDtb, offset, propertyInfo);\r
 -      }\r
 -        else if (offset != -FDT_ERR_NOTFOUND) {\r
 -            /* Error returned by LIBFDT */\r
 -            retVal = offset;\r
 -        }\r
 -    }\r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Recursively parses GRL resource nodes\r
 - ***********************************************************************\r
 - * DESCRIPTION: Recursively parses GRL resource nodes looking for\r
 - *              resource properties to create the resource allocators.\r
 - *              The LIBFDT APIs are used to parse the GRL.\r
 - */\r
 -static int32_t parseResourceNode(Rm_Inst *rmInst, void *globalResourceDtb, int32_t nodeOffset, int32_t depth,\r
 -                                 void *linuxDtb)\r
 -{\r
 -      const char            *resourceName = fdt_get_name(globalResourceDtb, nodeOffset, NULL);\r
 -    Rm_ResourceProperties  resourceProperties;\r
 -      int32_t                retVal = RM_OK;\r
 -      int32_t                offset;\r
 -\r
 -    memset((void *)&resourceProperties, 0, sizeof(Rm_ResourceProperties));\r
 -    /* Get properties of resource node */\r
 -      offset = fdt_first_property_offset(globalResourceDtb, nodeOffset);\r
 -      if (offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) {\r
 -              retVal =  parseResourceProperty(globalResourceDtb, offset, &resourceProperties);\r
 -        if (retVal < -FDT_ERR_NOTFOUND) {\r
 -            return (retVal);\r
 -        }\r
 -        if (retVal = createAndInitAllocator(rmInst, resourceName, &resourceProperties, linuxDtb) < RM_OK) {\r
 -            return (retVal);\r
 -        }\r
 -      }\r
 -    else if (offset != -FDT_ERR_NOTFOUND) {\r
 -              /* Error returned by LIBFDT */\r
 -        return (offset);\r
 -    }\r
 -    \r
 -      offset = fdt_next_node(globalResourceDtb, nodeOffset, &depth);\r
 -    if ((offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) && (depth >= RM_DTB_UTIL_STARTING_DEPTH)) {\r
 -        retVal = parseResourceNode(rmInst, globalResourceDtb, offset, depth, linuxDtb);\r
 -        if (retVal < -FDT_ERR_NOTFOUND) {\r
 -            return (retVal);\r
 -        }\r
 -    }\r
 -    else if (offset != -FDT_ERR_NOTFOUND) {\r
 -        /* Error returned by LIBFDT */\r
 -        return (offset);\r
 -    }\r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Initializes server allocators\r
 - ***********************************************************************\r
 - * DESCRIPTION: Creates and initializes a server instance's\r
 - *              resource allocators using the GRL and, if\r
 - *              provided, Linux DTB.\r
 - */\r
 -static int32_t initializeAllocators(Rm_Inst *rmInst, void *globalResourceDtb, void *linuxDtb)\r
 -{\r
 -    int32_t nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;\r
 -    int32_t startDepth = RM_DTB_UTIL_STARTING_DEPTH;\r
 -    int32_t result = RM_OK;\r
 -\r
 -    /* Recursively parse the Global Resource List, creating an allocator for\r
 -     * each resource as specified in the node */\r
 -    result = parseResourceNode(rmInst, globalResourceDtb, nodeOffset, startDepth, linuxDtb);\r
 -\r
 -    return(result);\r
 -}\r
 -\r
 -/**********************************************************************\r
 - ********************** Internal Functions ****************************\r
 - **********************************************************************/\r
 -\r
 -/* FUNCTION PURPOSE: Adds a transaction\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a pointer to a newly created transaction.\r
 - *              The transaction is created based on a new service\r
 - *              request received via the service API or the\r
 - *              transport API (service forwarded from another instance)\r
 - */\r
 -Rm_Transaction *rmTransactionQueueAdd(Rm_Inst *rmInst)\r
 -{\r
 -    Rm_Transaction *transactionQueue = rmInst->transactionQueue;\r
 -    Rm_Transaction *newTransaction   = NULL;\r
 -\r
 -    newTransaction = Rm_osalMalloc(sizeof(Rm_Transaction));\r
 -    if (newTransaction) {\r
 -        memset((void *)newTransaction, 0, sizeof(Rm_Transaction));\r
 -\r
 -        newTransaction->localId = transactionGetSequenceNum(rmInst);\r
 -        newTransaction->nextTransaction = NULL;  \r
 -        if (transactionQueue) {\r
 -            while (transactionQueue->nextTransaction) {\r
 -                transactionQueue = transactionQueue->nextTransaction;\r
 -            }\r
 -            transactionQueue->nextTransaction = newTransaction;\r
 -        }\r
 -        else {\r
 -            rmInst->transactionQueue = newTransaction;\r
 -        }\r
 -    }\r
 -    return (newTransaction);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Finds a transaction\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a pointer to a transaction resident\r
 - *              in the transaction queue that matches the provided\r
 - *              transaction ID.\r
 - */\r
 -Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId)\r
 -{\r
 -    Rm_Transaction *transaction = rmInst->transactionQueue;\r
 -\r
 -    while (transaction) {\r
 -        if (transaction->localId == transactionId) {\r
 -            break;             \r
 -        }\r
 -        transaction = transaction->nextTransaction;\r
 -    }\r
 -\r
 -    return (transaction);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Deletes a transaction\r
 - ***********************************************************************\r
 - * DESCRIPTION: Deletes the transaction with the provided transaction\r
 - *              ID from the instance's transaction queue.\r
 - */\r
 -int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)\r
 -{\r
 -    Rm_Transaction *transaction     = rmInst->transactionQueue;\r
 -    Rm_Transaction *prevTransaction = NULL;\r
 -    int32_t         retVal          = RM_OK;\r
 -\r
 -    while (transaction) {\r
 -        if (transaction->localId == transactionId) {\r
 -            break;             \r
 -        }\r
 -\r
 -        prevTransaction = transaction;\r
 -        transaction = transaction->nextTransaction;\r
 -    }\r
 -\r
 -    if (transaction) {\r
 -        if (prevTransaction == NULL) {\r
 -            /* Transaction at start of queue. Map second transaction to start of queue \r
 -             * as long as more than one transactions. */\r
 -            rmInst->transactionQueue = transaction->nextTransaction;\r
 -        }\r
 -        else {\r
 -            /* Transaction in middle or end of queue. */\r
 -            prevTransaction->nextTransaction = transaction->nextTransaction;\r
 -        }\r
 -        Rm_osalFree((void *)transaction, sizeof(Rm_Transaction));\r
 -    }\r
 -    else {\r
 -        retVal = RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST;\r
 -    }    \r
 -    return (retVal);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Finds an allocator\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a pointer to an allocator that matches the \r
 - *              provided resource name.\r
 - */\r
 -Rm_Allocator *rmAllocatorFind(Rm_Allocator *allocatorList, char *resourceName)\r
 -{\r
 -    while (allocatorList) {\r
 -        if (strncmp(allocatorList->resourceName, resourceName, RM_NAME_MAX_CHARS) == 0) {\r
 -            break;             \r
 -        }\r
 -        allocatorList = allocatorList->nextAllocator;\r
 -    }\r
 -\r
 -    return (allocatorList);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Processes a transaction\r
 - ***********************************************************************\r
 - * DESCRIPTION: Processes transactions created from services\r
 - *              received via the service handle or the transport.\r
 - *              Transactions will be routed within the RM system\r
 - *              based on the RM instance type and the type of\r
 - *              the transaction.\r
 - */\r
 -void rmTransactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 -{\r
 -    void                *validInstNode;\r
 -    Rm_PolicyCheckCfg    privCheckCfg;\r
 -    Rm_NameServerObjCfg  nameServerObjCfg;      \r
 -    uint32_t             allocType = 0;    \r
 -\r
 -    /* Handle static transactions originating on this instance.  Any other static transactions will be\r
 -     * stored in transaction queue until all transports are up. */\r
 -    if (((rmInst->instType == Rm_instType_CLIENT) || (rmInst->instType == Rm_instType_CLIENT_DELEGATE)) &&\r
 -        (!rmInst->registeredWithDelegateOrServer) && \r
 -        (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS) == 0)) {\r
 -        if (rmInst->staticInfo.staticPolicy) {\r
 -            if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||\r
 -                (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE)) {\r
 -                /* Check request against startup policy */\r
 -                memset((void *)&privCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));\r
 -\r
 -                if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {\r
 -                    privCheckCfg.type = Rm_policyCheck_INIT;\r
 -                }\r
 -                else {\r
 -                    privCheckCfg.type = Rm_policyCheck_USE;\r
 -                }\r
 -                privCheckCfg.policyDtb = rmInst->staticInfo.staticPolicy;\r
 -                privCheckCfg.validInstNode = rmPolicyGetValidInstNode(rmInst->staticInfo.staticValidInstTree, \r
 -                                                                      rmInst->instName);\r
 -                privCheckCfg.resourceOffset = rmPolicyGetResourceOffset(rmInst->staticInfo.staticPolicy,\r
 -                                                                        transaction->resourceInfo.name);\r
 -                privCheckCfg.resourceBase = transaction->resourceInfo.base;\r
 -                privCheckCfg.resourceLength = transaction->resourceInfo.length;\r
 -\r
 -                if (rmPolicyCheckPrivilege(&privCheckCfg, &transaction->state)) {\r
 -                    transaction->state = RM_SERVICE_APPROVED_STATIC;\r
 -                }\r
 -                else if (transaction->state == RM_SERVICE_PROCESSING) {\r
 -                    /* Privilege check returned false without error */\r
 -                    transaction->state = RM_SERVICE_DENIED_BY_STATIC_POLICY;\r
 -                }\r
 -            }\r
 -            else {\r
 -                transaction->state = RM_SERVICE_DENIED_INVALID_STATIC_REQUEST;\r
 -            }\r
 -        }\r
 -        else {\r
 -            transaction->state = RM_ERROR_REQ_FAILED_NO_STATIC_POLICY;\r
 -        }        \r
 -    }\r
 -    else {\r
 -        /* Handle auto-forwarded transactions.  These transactions include:\r
 -         * - All request transactions received on Clients are forwarded to the Client Delegate\r
 -         * - NameServer requests received on the Client Delegate are forwarded to the Server */\r
 -        if ((rmInst->instType == Rm_instType_CLIENT) ||\r
 -            ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
 -             ((transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) ||\r
 -              (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) ||\r
 -              (transaction->type == Rm_service_RESOURCE_UNMAP_NAME)))) {\r
 -              \r
 -            if ((transaction->state != RM_SERVICE_PROCESSING) &&\r
 -                (transaction->state != RM_SERVICE_APPROVED_STATIC)) {\r
 -                if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -                    /* Transaction did not originate on this instance */\r
 -                    transactionResponder(rmInst, transaction);\r
 -                }\r
 -                else {\r
 -                    /* Transaction originated on this instance */\r
 -                    serviceResponder(rmInst, transaction);\r
 -                }\r
 -            }\r
 -            else {\r
 -                /* Forward request if transport is up.  Otherwise, just queue. */\r
 -                if (rmInst->registeredWithDelegateOrServer) {\r
 -                    transactionForwarder(rmInst, transaction);   \r
 -                } \r
 -            }\r
 -        }\r
 -        else {\r
 -            /* Validate service's originating instance name */\r
 -            if (rmInst->instType == Rm_instType_SERVER) {\r
 -                validInstNode = rmPolicyGetValidInstNode(rmInst->validInstances, transaction->serviceSrcInstName);\r
 -                if (validInstNode == NULL) {\r
 -                    transaction->state = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;\r
 -\r
 -                    /* Send result via responder if transaction did not originate from this instance */\r
 -                    if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -                        transactionResponder(rmInst, transaction);\r
 -                    }\r
 -                }\r
 -            }\r
 -\r
 -            switch (transaction->type) {\r
 -                case Rm_service_RESOURCE_ALLOCATE_INIT:\r
 -                case Rm_service_RESOURCE_ALLOCATE_USE:\r
 -                case Rm_service_RESOURCE_FREE:               \r
 -                    if ((transaction->state != RM_SERVICE_PROCESSING) &&\r
 -                        (transaction->state != RM_SERVICE_APPROVED_STATIC)) {\r
 -                        /* Transaction complete */\r
 -                        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -                            /* Transaction result not destined for this instance */\r
 -                            transactionResponder(rmInst, transaction);\r
 -                        }\r
 -                        else {\r
 -                            /* Transaction result destined for this instance */\r
 -                            serviceResponder(rmInst, transaction);      \r
 -                        }\r
 -                    }\r
 -                    else {\r
 -                        /* Complete allocation/free request */\r
 -                        if (transaction->type == Rm_service_RESOURCE_FREE) {\r
 -                            freeHandler(rmInst, transaction, validInstNode);\r
 -                        }\r
 -                        else {\r
 -                            switch (transaction->type) {\r
 -                                case Rm_service_RESOURCE_ALLOCATE_INIT:\r
 -                                    RM_policy_SET_PERM(allocType, RM_POLICY_PERM_INIT_SHIFT, 1);\r
 -                                    break;\r
 -                                case Rm_service_RESOURCE_ALLOCATE_USE:\r
 -                                    RM_policy_SET_PERM(allocType, RM_POLICY_PERM_USE_SHIFT, 1);    \r
 -                                    break;\r
 -                            }\r
 -                            allocationHandler(rmInst, transaction, validInstNode, allocType);\r
 -                        }\r
 -                    }\r
 -                    break;\r
 -                case Rm_service_RESOURCE_MAP_TO_NAME:\r
 -                case Rm_service_RESOURCE_GET_BY_NAME:\r
 -                case Rm_service_RESOURCE_UNMAP_NAME:                \r
 -                    /* NameServer resides on server */\r
 -                    memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));\r
 -                    if (rmInst->nameServer) {\r
 -                        nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
 -                        nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;\r
 -                        if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) {\r
 -                            nameServerObjCfg.nodeCfg.resourceName = transaction->resourceInfo.name;\r
 -                            nameServerObjCfg.nodeCfg.resourceBase= transaction->resourceInfo.base;\r
 -                            nameServerObjCfg.nodeCfg.resourceLength = transaction->resourceInfo.length;\r
 -                            transaction->state = rmNameServerAddObject(&nameServerObjCfg);\r
 -                        }\r
 -                        else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {\r
 -                            if ((transaction->state = rmNameServerFindObject(&nameServerObjCfg)) ==\r
 -                                RM_SERVICE_PROCESSING) {\r
 -                                strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
 -                                transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
 -                                transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
 -                                transaction->state = RM_SERVICE_APPROVED;\r
 -                            } \r
 -                        }\r
 -                        else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {\r
 -                            transaction->state = rmNameServerDeleteObject(&nameServerObjCfg);\r
 -                        }\r
 -                    }\r
 -                    else {\r
 -                        transaction->state = RM_ERROR_NAMESERVER_DOES_NOT_EXIST;\r
 -                    }\r
 -\r
 -                    /* Send result via responder if transaction did not originate from this instance */\r
 -                    if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {\r
 -                        transactionResponder(rmInst, transaction);\r
 -                    }\r
 -                    break;\r
 -            }\r
 -        }\r
 -    }\r
 -\r
 -    /* Forward any queued requests that weren't forwarded yet */\r
 -    if (rmInst->registeredWithDelegateOrServer) {\r
 -        transaction = rmInst->transactionQueue;\r
 -        while(transaction) {\r
 -            if (((transaction->state == RM_SERVICE_PROCESSING) ||\r
 -                 (transaction->state == RM_SERVICE_APPROVED_STATIC)) &&\r
 -                !transaction->hasBeenForwarded) {\r
 -                transactionForwarder(rmInst, transaction);\r
 -            }\r
 -            transaction = transaction->nextTransaction;\r
 -        }\r
 -    }\r
 -}\r
 -     \r
 -/**********************************************************************\r
 - ********************** Application visible APIs **********************\r
 - **********************************************************************/\r
 -\r
 -/* FUNCTION PURPOSE: Display status of managed resources\r
 - ***********************************************************************\r
 - * DESCRIPTION: Prints the status (allocate/free status, as well as\r
 - *              owners) for all resources managed by the RM \r
 - *              instance network.  Also, prints the NameServer name\r
 - *              entries.  This function is only available on server\r
 - *              instances.\r
 - */\r
 -void Rm_printResourceStatus(Rm_Handle rmServerHandle)\r
 -{\r
 -    Rm_Inst         *rmInst = (Rm_Inst *)rmServerHandle;\r
 -    Rm_Allocator    *allocator = rmInst->allocators;\r
 -    Rm_Owner        *owners;\r
 -    Rm_ResourceTree *treeRoot;\r
 -    Rm_ResourceNode *treeNode;\r
 -\r
 -    if (rmInst->instType == Rm_instType_SERVER) {\r
 -        while (allocator != NULL) {\r
 -            Rm_osalLog("Resource: %s\n", allocator->resourceName);\r
 -\r
 -            treeRoot = allocator->allocatorRootEntry;\r
 -\r
 -            RB_FOREACH(treeNode, _Rm_AllocatorResourceTree, treeRoot) {               \r
 -                Rm_osalLog("          %10d - %10d ", treeNode->base, \r
 -                                                     treeNode->base + treeNode->length -1);\r
 -                \r
 -                if (treeNode->allocationCount == 0) {\r
 -                    Rm_osalLog("NOT ALLOCATED\n");\r
 -                }\r
 -                else {\r
 -                    owners = treeNode->ownerList;\r
 -                    Rm_osalLog("allocated to");\r
 -                    while (owners) {\r
 -                        Rm_osalLog(" %s", owners->instNameNode->name);\r
 -                        owners = owners->nextOwner;\r
 -                    }\r
 -                    Rm_osalLog("\n");\r
 -                }\r
 -            }        \r
 -            allocator = allocator->nextAllocator;\r
 -        }\r
 -        rmNameServerPrintObjects(rmInst->nameServer);\r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Display status of a RM instance\r
 - ***********************************************************************\r
 - * DESCRIPTION: Prints the current status of various RM instance\r
 - *              properties such as the state of all transactions\r
 - *              in the transaction queue and registered transports\r
 - */\r
 -void Rm_printInstanceStatus(Rm_Handle rmHandle)\r
 -{\r
 -    Rm_Inst        *rmInst = (Rm_Inst *)rmHandle;\r
 -    Rm_Transport   *transportList = (Rm_Transport *)rmInst->transports;\r
 -    Rm_Transaction *transactionQ = rmInst->transactionQueue;\r
 -\r
 -    Rm_osalLog("Instance name: %s\n", rmInst->instName);\r
 -    if (rmInst->instType == Rm_instType_SERVER) {\r
 -        Rm_osalLog("Type: Server\n");\r
 -    }\r
 -    else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {\r
 -        Rm_osalLog("Type: Client Delegate\n");\r
 -    }\r
 -    else {\r
 -        Rm_osalLog("Type: Client\n");\r
 -    }\r
 -\r
 -    if (transportList) {\r
 -        Rm_osalLog("\nRegistered Transports:\n");\r
 -        while (transportList) {\r
 -            Rm_osalLog("    Remote instName:    %s\n", transportList->remoteInstName);\r
 -            if (transportList->remoteInstType == Rm_instType_SERVER) {\r
 -                Rm_osalLog("    Remote instType:    Server\n");\r
 -            }\r
 -            else if (transportList->remoteInstType == Rm_instType_CLIENT_DELEGATE) {\r
 -                Rm_osalLog("    Remote instType:    Client Delegate\n");\r
 -            }\r
 -            else {\r
 -                Rm_osalLog("    Remote instType:    Client\n");\r
 -            }\r
 -            Rm_osalLog("    appTransportHandle: 0x%08x\n", transportList->appTransportHandle);\r
 -            Rm_osalLog("\n");\r
 -            transportList = transportList->nextTransport;\r
 -        }\r
 -    }\r
 -\r
 -    if (transactionQ) {\r
 -        Rm_osalLog("\nQueued Service Transactions:\n");\r
 -        while (transactionQ) {\r
 -            Rm_osalLog("    Service type:       %d\n", transactionQ->type);\r
 -            Rm_osalLog("    Service ID:         %d\n", transactionQ->localId);\r
 -            Rm_osalLog("    Service srcInstName %s\n", transactionQ->serviceSrcInstName);\r
 -            Rm_osalLog("    Service state:      %d\n", transactionQ->state);\r
 -            Rm_osalLog("    Resource name:      %s\n", transactionQ->resourceInfo.name);\r
 -            Rm_osalLog("    Resource base:      %d\n", transactionQ->resourceInfo.base);\r
 -            Rm_osalLog("    Resource length:    %d\n", transactionQ->resourceInfo.length);\r
 -            Rm_osalLog("    Resource alignment: %d\n", transactionQ->resourceInfo.alignment);\r
 -            Rm_osalLog("    Resource NS name:   %s\n", transactionQ->resourceInfo.nameServerName);\r
 -            Rm_osalLog("\n");\r
 -            transactionQ = transactionQ->nextTransaction;\r
 -        }    \r
 -    }\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: RM instance creation and initialization\r
 - ***********************************************************************\r
 - * DESCRIPTION: Returns a new RM instance created and initialized\r
 - *              using the parameters provided via the initCfg\r
 - *              structure.\r
 - */\r
 -Rm_Handle Rm_init(Rm_InitCfg *initCfg, int32_t *result)\r
 -{\r
 -    Rm_Inst *rmInst;\r
 -    void    *globalResourceDtb = NULL;\r
 -    void    *linuxResourceDtb = NULL;\r
 -    bool     addLinux = false;\r
 -\r
 -    *result = RM_OK;\r
 -    \r
 -    if ((initCfg->instName == NULL) ||\r
 -        ((strlen(initCfg->instName) + 1) > RM_NAME_MAX_CHARS)) {\r
 -        *result = RM_ERROR_INVALID_INST_NAME;\r
 -        return (NULL);\r
 -    }\r
 -\r
 -    if (initCfg->instType >= Rm_instType_LAST) {\r
 -        *result = RM_ERROR_INVALID_INST_TYPE;\r
 -    }\r
 -\r
 -    /* Create and initialize instance */\r
 -    rmInst = Rm_osalMalloc (sizeof(Rm_Inst));\r
 -    memset ((void *) rmInst, 0, sizeof(Rm_Inst));\r
 -    rmInst->isLocked = false;\r
 -    rmInst->registeredWithDelegateOrServer = false;\r
 -    rmInst->transactionSeqNum = transactionInitSequenceNum();\r
 -\r
 -    rmInst->instType = initCfg->instType;    \r
 -    strncpy (rmInst->instName, initCfg->instName, RM_NAME_MAX_CHARS);\r
 -\r
 -    if (rmInst->instType == Rm_instType_SERVER) {\r
 -        if (!initCfg->instCfg.serverCfg.globalResourceList ||\r
 -            !initCfg->instCfg.serverCfg.globalPolicy) {\r
 -            *result = RM_ERROR_INVALID_SERVER_CONFIGURATION;\r
 -            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));\r
 -            return(NULL);\r
 -        }\r
 -\r
 -        rmInst->policy = initCfg->instCfg.serverCfg.globalPolicy;\r
 -        fdt_open_into(rmInst->policy, rmInst->policy, fdt_totalsize(rmInst->policy)); \r
 -\r
 -        if (initCfg->instCfg.serverCfg.linuxDtb) {\r
 -            linuxResourceDtb = initCfg->instCfg.serverCfg.linuxDtb;\r
 -            fdt_open_into(linuxResourceDtb, linuxResourceDtb, fdt_totalsize(linuxResourceDtb));\r
 -            addLinux = true;\r
 -        }\r
 -\r
 -        /* Create valid instance list from policy.  Must be done prior to parsing\r
 -         * GRL so that Linux resources can be reserved correctly */\r
 -        rmInst->validInstances = rmPolicyCreateValidInstTree(rmInst->policy, addLinux, result);\r
 -        /* Validate policy assignment strings */\r
 -        *result = rmPolicyValidatePolicy(rmInst->policy, rmInst->validInstances);  \r
 -\r
 -        rmInst->nameServer = rmNameServerInit();\r
 -\r
 -        globalResourceDtb = initCfg->instCfg.serverCfg.globalResourceList;\r
 -        fdt_open_into(globalResourceDtb, globalResourceDtb, fdt_totalsize(globalResourceDtb));\r
 -\r
 -        if ((*result = initializeAllocators(rmInst, globalResourceDtb, linuxResourceDtb)) == RM_OK) {  \r
 -            *result = rmPolicyValidatePolicyResourceNames(rmInst->policy, (void *)rmInst->allocators);\r
 -        }\r
 -        if (*result < RM_OK) {\r
 -            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));\r
 -            return(NULL);\r
 -        }\r
 -    }\r
 -\r
 -    if ((rmInst->instType == Rm_instType_CLIENT) && \r
 -        (initCfg->instCfg.clientCfg.staticPolicy)) {\r
 -        rmInst->staticInfo.staticPolicy = initCfg->instCfg.clientCfg.staticPolicy; \r
 -    }\r
 -    else if ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
 -             (initCfg->instCfg.cdCfg.staticPolicy)) { \r
 -        rmInst->staticInfo.staticPolicy = initCfg->instCfg.cdCfg.staticPolicy; \r
 -    }\r
 -    if (rmInst->staticInfo.staticPolicy) {\r
 -        fdt_open_into(rmInst->staticInfo.staticPolicy, rmInst->staticInfo.staticPolicy, \r
 -                      fdt_totalsize(rmInst->staticInfo.staticPolicy));       \r
 -        rmInst->staticInfo.staticValidInstTree = rmPolicyCreateValidInstTree(rmInst->staticInfo.staticPolicy, \r
 -                                                                             addLinux, result);        \r
 -        if (*result == RM_OK) {\r
 -            /* Validate policy assignment strings */\r
 -            *result = rmPolicyValidatePolicy(rmInst->staticInfo.staticPolicy, rmInst->staticInfo.staticValidInstTree);\r
 -        }\r
 -        if (*result != RM_OK) {\r
 -            if (rmInst->staticInfo.staticValidInstTree) {\r
 -                rmPolicyFreeValidInstTree(rmInst->staticInfo.staticValidInstTree);\r
 -            }\r
 -            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));\r
 -            rmInst = NULL;\r
 -        }\r
 -    }\r
 -    return ((Rm_Handle) rmInst);\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Returns RM version information\r
 - ***********************************************************************\r
 - */\r
 -uint32_t Rm_getVersion (void)\r
 -{\r
 -    return RM_VERSION_ID;\r
 -}\r
 -\r
 -/* FUNCTION PURPOSE: Returns RM version string\r
 - ***********************************************************************\r
 - */\r
 -const char* Rm_getVersionStr (void)\r
 -{\r
 -    return rmVersionStr;\r
 -}\r
 -\r
 +/**
 + *   @file  rm.c
 + *
 + *   @brief   
-  *      This is the Resource Manager Low Level Driver file.
++ *      This is the Resource Manager source.
 + *
 + *  \par
 + *  ============================================================================
-  *  @n   (C) Copyright 2012, Texas Instruments, Inc.
++ *  @n   (C) Copyright 2012-2013, Texas Instruments, Inc.
 + * 
 + *  Redistribution and use in source and binary forms, with or without 
 + *  modification, are permitted provided that the following conditions 
 + *  are met:
 + *
 + *    Redistributions of source code must retain the above copyright 
 + *    notice, this list of conditions and the following disclaimer.
 + *
 + *    Redistributions in binary form must reproduce the above copyright
 + *    notice, this list of conditions and the following disclaimer in the 
 + *    documentation and/or other materials provided with the   
 + *    distribution.
 + *
 + *    Neither the name of Texas Instruments Incorporated nor the names of
 + *    its contributors may be used to endorse or promote products derived
 + *    from this software without specific prior written permission.
 + *
 + *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 + *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 + *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 + *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 + *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 + *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 + *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 + *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 + *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 + *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 + *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 + *
 + *  \par
 +*/
 +
- /* c99 include */
++/* Standard includes */
 +#include <stdint.h>
- #include <stdlib.h>
++#include <string.h>
++#include <stdbool.h>
 +
- /* RM includes */
++/* RM external includes */
 +#include <ti/drv/rm/rm.h>
- #include <ti/drv/rm/rm_public_lld.h>
- #include <ti/drv/rm/resource_table_defs.h>
- #include <ti/drv/rm/include/rm_pvt.h>
++#include <ti/drv/rm/rmver.h>
++#include <ti/drv/rm/rm_services.h>
++#include <ti/drv/rm/rm_transport.h>
++
++/* RM internal includes */
++#include <ti/drv/rm/include/rm_loc.h>
++#include <ti/drv/rm/include/rm_transportloc.h>
++#include <ti/drv/rm/include/rm_nameserverloc.h>
++#include <ti/drv/rm/include/rm_dtb_utilloc.h>
++#include <ti/drv/rm/include/rm_policyloc.h>
++#include <ti/drv/rm/include/rm_treeloc.h>
++
++/* RM LIBFDT includes */
++#include <ti/drv/rm/util/libfdt/libfdt.h>
++
++/* Tree algorithm includes */
++#include <ti/drv/rm/util/tree.h>
 +
 +/* RM OSAL layer */
 +#include <rm_osal.h>
 +
- /* CSL includes */
- #include <ti/csl/csl_qm_queue.h>
 +/**********************************************************************
 + ************************** Globals ***********************************
 + **********************************************************************/
 +
- /* Place QMSS PDSP permissions array */
- #pragma DATA_SECTION (rmQmssPdspFirmwarePerms, ".rm");
- #pragma DATA_ALIGN (rmQmssPdspFirmwarePerms, 128)
- Rm_Perms rmQmssPdspFirmwarePerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_FIRMWARE_PDSPS, Rm_Perms)];
- /* Place QMSS queue permissions array */
- #pragma DATA_SECTION (rmQmssQueuePerms, ".rm");
- #pragma DATA_ALIGN (rmQmssQueuePerms, 128)
- Rm_Perms rmQmssQueuePerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_QUEUES, Rm_Perms)];
- /* Place QMSS memory region permissions array */
- #pragma DATA_SECTION (rmQmssMemRegionPerms, ".rm");
- #pragma DATA_ALIGN (rmQmssMemRegionPerms, 128)
- Rm_Perms rmQmssMemRegionPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_MEM_REGIONS, Rm_Perms)];
- /* Place QMSS Linking RAM permissions array */
- #pragma DATA_SECTION (rmQmssLinkingRamPerms, ".rm");
- #pragma DATA_ALIGN (rmQmssLinkingRamPerms, 128)
- Rm_qmssLinkingRamPerms rmQmssLinkingRamPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_LINKING_RAM_RANGES, Rm_qmssLinkingRamPerms)];
- /* Place QMSS accumulator channel permissions array */
- #pragma DATA_SECTION (rmQmssAccumChPerms, ".rm");
- #pragma DATA_ALIGN (rmQmssAccumChPerms, 128)
- Rm_Perms rmQmssAccumChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_ACCUM_CH, Rm_Perms)];
- /* Place QMSS QOS cluster permissions array */
- #pragma DATA_SECTION (rmQmssQosClusterPerms, ".rm");
- #pragma DATA_ALIGN (rmQmssQosClusterPerms, 128)
- Rm_Perms rmQmssQosClusterPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_QOS_CLUSTER, Rm_Perms)];
- /* Place QMSS QOS queue permissions array */
- #pragma DATA_SECTION (rmQmssQosQueuePerms, ".rm");
- #pragma DATA_ALIGN (rmQmssQosQueuePerms, 128)
- Rm_Perms rmQmssQosQueuePerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_QOS_QUEUES, Rm_Perms)];
- /* Place CPPI SRIO TX channel permissions array */
- #pragma DATA_SECTION (rmCppiSrioTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiSrioTxChPerms, 128)
- Rm_Perms rmCppiSrioTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_SRIO_TX_CH, Rm_Perms)];
- #ifdef QMSS_MAX_AIF_QUEUE
- /* Place CPPI AIF TX channel permissions array */
- #pragma DATA_SECTION (rmCppiAifTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiAifTxChPerms, 128)
- Rm_Perms rmCppiAifTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_AIF_TX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_A_QUEUE
- /* Place CPPI FFTC A TX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcATxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcATxChPerms, 128)
- Rm_Perms rmCppiFftcATxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_A_TX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_B_QUEUE
- /* Place CPPI FFTC B TX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcBTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcBTxChPerms, 128)
- Rm_Perms rmCppiFftcBTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_B_TX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_PASS_QUEUE
- /* Place CPPI PASS TX channel permissions array */
- #pragma DATA_SECTION (rmCppiPassTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiPassTxChPerms, 128)
- Rm_Perms rmCppiPassTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_PASS_TX_CH, Rm_Perms)];
- #endif
- /* Place CPPI QMSS TX channel permissions array */
- #pragma DATA_SECTION (rmCppiQmssTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiQmssTxChPerms, 128)
- Rm_Perms rmCppiQmssTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_QMSS_TX_CH, Rm_Perms)];
- #ifdef QMSS_MAX_FFTC_C_QUEUE
- /* Place CPPI FFTC C TX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcCTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcCTxChPerms, 128)
- Rm_Perms rmCppiFftcCTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_C_TX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
- /* Place CPPI BCP TX channel permissions array */
- #pragma DATA_SECTION (rmCppiBcpTxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiBcpTxChPerms, 128)
- Rm_Perms rmCppiBcpTxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_BCP_TX_CH, Rm_Perms)];
- #endif
- /* Place CPPI SRIO RX channel permissions array */
- #pragma DATA_SECTION (rmCppiSrioRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiSrioRxChPerms, 128)
- Rm_Perms rmCppiSrioRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_SRIO_RX_CH, Rm_Perms)];
- #ifdef QMSS_MAX_AIF_QUEUE
- /* Place CPPI AIF RX channel permissions array */
- #pragma DATA_SECTION (rmCppiAifRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiAifRxChPerms, 128)
- Rm_Perms rmCppiAifRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_AIF_RX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_A_QUEUE
- /* Place CPPI FFTC A RX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcARxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcARxChPerms, 128)
- Rm_Perms rmCppiFftcARxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_A_RX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_B_QUEUE
- /* Place CPPI FFTC B RX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcBRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcBRxChPerms, 128)
- Rm_Perms rmCppiFftcBRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_B_RX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_PASS_QUEUE
- /* Place CPPI PASS RX channel permissions array */
- #pragma DATA_SECTION (rmCppiPassRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiPassRxChPerms, 128)
- Rm_Perms rmCppiPassRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_PASS_RX_CH, Rm_Perms)];
- #endif
- /* Place CPPI QMSS RX channel permissions array */
- #pragma DATA_SECTION (rmCppiQmssRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiQmssRxChPerms, 128)
- Rm_Perms rmCppiQmssRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_QMSS_RX_CH, Rm_Perms)];
- #ifdef QMSS_MAX_FFTC_C_QUEUE
- /* Place CPPI FFTC C RX channel permissions array */
- #pragma DATA_SECTION (rmCppiFftcCRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcCRxChPerms, 128)
- Rm_Perms rmCppiFftcCRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_C_RX_CH, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
- /* Place CPPI BCP RX channel permissions array */
- #pragma DATA_SECTION (rmCppiBcpRxChPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiBcpRxChPerms, 128)
- Rm_Perms rmCppiBcpRxChPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_BCP_RX_CH, Rm_Perms)];
- #endif
- /* Place CPPI SRIO flow permissions array */
- #pragma DATA_SECTION (rmCppiSrioFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiSrioFlowPerms, 128)
- Rm_Perms rmCppiSrioFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_SRIO_FLOW, Rm_Perms)];
- #ifdef QMSS_MAX_AIF_QUEUE
- /* Place CPPI AIF flow permissions array */
- #pragma DATA_SECTION (rmCppiAifFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiAifFlowPerms, 128)
- Rm_Perms rmCppiAifFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_AIF_FLOW, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_A_QUEUE
- /* Place CPPI FFTC A flow permissions array */
- #pragma DATA_SECTION (rmCppiFftcAFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcAFlowPerms, 128)
- Rm_Perms rmCppiFftcAFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_A_FLOW, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_FFTC_B_QUEUE
- /* Place CPPI FFTC B flow permissions array */
- #pragma DATA_SECTION (rmCppiFftcBFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcBFlowPerms, 128)
- Rm_Perms rmCppiFftcBFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_B_FLOW, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_PASS_QUEUE
- /* Place CPPI PASS flow permissions array */
- #pragma DATA_SECTION (rmCppiPassFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiPassFlowPerms, 128)
- Rm_Perms rmCppiPassFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_PASS_FLOW, Rm_Perms)];
- #endif
- /* Place CPPI QMSS flow permissions array */
- #pragma DATA_SECTION (rmCppiQmssFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiQmssFlowPerms, 128)
- Rm_Perms rmCppiQmssFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_QMSS_FLOW, Rm_Perms)];
- #ifdef QMSS_MAX_FFTC_C_QUEUE
- /* Place CPPI FFTC C flow permissions array */
- #pragma DATA_SECTION (rmCppiFftcCFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiFftcCFlowPerms, 128)
- Rm_Perms rmCppiFftcCFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_FFTC_C_FLOW, Rm_Perms)];
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
- /* Place CPPI BCP flow permissions array */
- #pragma DATA_SECTION (rmCppiBcpFlowPerms, ".rm");
- #pragma DATA_ALIGN (rmCppiBcpFlowPerms, 128)
- Rm_Perms rmCppiBcpFlowPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_CPPI_BCP_FLOW, Rm_Perms)];
- #endif
- /* Place PA lookup table permissions array */
- #pragma DATA_SECTION (rmPaLutPerms, ".rm");
- #pragma DATA_ALIGN (rmPaLutPerms, 128)
- Rm_Perms rmPaLutPerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_PA_LUT, Rm_Perms)];
- /* Rm_init/Rm_start synchronization object.  Initialized to 0. */
- #pragma DATA_SECTION (rmGSyncObj, ".rm");
- #pragma DATA_ALIGN (rmGSyncObj, 128)
- Rm_Sync_Obj rmGSyncObj = 
++/** @brief Global Variable which describes the RM Version Information */
++const char  rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;
++
++/**********************************************************************
++ ************************ Local Functions *****************************
++ **********************************************************************/
++
++/* FUNCTION PURPOSE: Initializes a RM inst's transaction sequence number
++ ***********************************************************************
++ * DESCRIPTION: The RM instance transaction sequence number can never
++ *              have a value of 0 to avoid conflicts with transactions
++ *              that have a remoteOriginatingId of 0 (transaction ID
++ *              will be used as the remoteOriginatingId for
++ *              transactions that are responses to requests).
++ */
++static uint32_t transactionInitSequenceNum(void)
 +{
-     {
-         RM_PERMISSION_TABLE_NOT_VALID,
++    return (1);
++}
++
++/* FUNCTION PURPOSE: Provides a sequence number for new transactions
++ ***********************************************************************
++ * DESCRIPTION: Returns a sequence number for a new transaction
++ *              specific to a RM instance.  Handles rollover of
++ *              sequence number.
++ */
++static uint32_t transactionGetSequenceNum(Rm_Inst *rmInst)
++{
++    uint32_t sequenceNum = 0;
++
++    if (rmInst->transactionSeqNum + 1 < rmInst->transactionSeqNum) {
++        /* Rollover */
++        sequenceNum = rmInst->transactionSeqNum;
++        rmInst->transactionSeqNum = transactionInitSequenceNum();
 +    }
- };
++    else {
++        sequenceNum = rmInst->transactionSeqNum++;
++    }    
++    return (sequenceNum);
++}
 +
- /* Create, populate, and place RM global permissions object */
- #pragma DATA_SECTION (rmGPermsObj, ".rm");
- #pragma DATA_ALIGN (rmGPermsObj, 128)
- Rm_GlobalPermissionsObj rmGPermsObj = 
++/* FUNCTION PURPOSE: Creates a resource allocator
++ ***********************************************************************
++ * DESCRIPTION: Returns a newly Created and initialized resource
++ *              The allocator is also stored in the RM instance
++ *              allocator list.            
++ */
++static Rm_Allocator *allocatorAdd(Rm_Inst *rmInst, const char *resourceName)
 +{
-     {
-         /* qmssPdspFirmwarePerms */
-         &rmQmssPdspFirmwarePerms[0],  
-         /* Pointer: qmssQueuePerms */
-         &rmQmssQueuePerms[0],
-         /* Pointer: qmssMemRegionPerms */
-         &rmQmssMemRegionPerms[0],
-         /* qmssLinkRamControlPerms */
-         {
-             0u,
-             0u,
-         },  
-         /* Pointer: qmssLinkRamPerms */
-         &rmQmssLinkingRamPerms[0],
-         /* Pointer: qmssAccumChPerms */
-         &rmQmssAccumChPerms[0], 
-         /* qmssQosPdspTimerPerms */
-         {
-             0u,
-             0u,
-         },  
-         /* Pointer: qmssQosClusterPerms */
-         &rmQmssQosClusterPerms[0],
-         /* Pointer: qmssQosQueuePerms */
-         &rmQmssQosQueuePerms[0],
-         /* Pointer array: cppiTxChPerms - Must be in same order as DMA objects */
-         {
-             { &rmCppiSrioTxChPerms[0], 
- #ifdef QMSS_MAX_AIF_QUEUE          
-                &rmCppiAifTxChPerms[0],
- #endif           
- #ifdef QMSS_MAX_FFTC_A_QUEUE           
-                &rmCppiFftcATxChPerms[0],
- #endif           
- #ifdef QMSS_MAX_FFTC_B_QUEUE           
-                &rmCppiFftcBTxChPerms[0],   
- #endif
- #ifdef QMSS_MAX_PASS_QUEUE
-                &rmCppiPassTxChPerms[0],
- #endif               
-                &rmCppiQmssTxChPerms[0],
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                &rmCppiFftcCTxChPerms[0],
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                &rmCppiBcpTxChPerms[0]
- #endif           
-             }
-         },
-         /* Pointer array: cppiRxChPerms - Must be in same order as DMA objects  */
-         {
-             { &rmCppiSrioRxChPerms[0], 
- #ifdef QMSS_MAX_AIF_QUEUE          
-                &rmCppiAifRxChPerms[0], 
- #endif           
- #ifdef QMSS_MAX_FFTC_A_QUEUE           
-                &rmCppiFftcARxChPerms[0],
- #endif           
- #ifdef QMSS_MAX_FFTC_B_QUEUE           
-                &rmCppiFftcBRxChPerms[0], 
- #endif           
- #ifdef QMSS_MAX_PASS_QUEUE
-                &rmCppiPassRxChPerms[0], 
- #endif               
-                &rmCppiQmssRxChPerms[0],
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                &rmCppiFftcCRxChPerms[0],
- #endif              
- #ifdef QMSS_MAX_BCP_QUEUE
-                &rmCppiBcpRxChPerms[0]
- #endif           
-             }
-         },    
-         /* Pointer array: cppiFlowPerms - Must be in same order as DMA objects  */
-         {
-             { &rmCppiSrioFlowPerms[0], 
- #ifdef QMSS_MAX_AIF_QUEUE          
-                &rmCppiAifFlowPerms[0], 
- #endif           
- #ifdef QMSS_MAX_FFTC_A_QUEUE           
-                &rmCppiFftcAFlowPerms[0],
- #endif           
- #ifdef QMSS_MAX_FFTC_B_QUEUE           
-                &rmCppiFftcBFlowPerms[0],    
- #endif           
- #ifdef QMSS_MAX_PASS_QUEUE
-                &rmCppiPassFlowPerms[0], 
- #endif               
-                &rmCppiQmssFlowPerms[0],
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                &rmCppiFftcCFlowPerms[0],
- #endif                     
- #ifdef QMSS_MAX_BCP_QUEUE
-                &rmCppiBcpFlowPerms[0]
- #endif           
++    Rm_Allocator *allocators   = rmInst->allocators;
++    Rm_Allocator *newAllocator = NULL;
++
++    newAllocator = Rm_osalMalloc(sizeof(Rm_Allocator));
++
++    if (newAllocator) {
++        memset((void *)newAllocator, 0, sizeof(Rm_Allocator));
++        strncpy(newAllocator->resourceName, resourceName, RM_NAME_MAX_CHARS);
++        newAllocator->allocatorRootEntry = NULL;
++        newAllocator->nextAllocator = NULL;  
++
++        /* Add allocator to end of list */
++        if (allocators) {
++            while (allocators->nextAllocator) {
++                allocators = allocators->nextAllocator;
 +            }
-         },
-         /* paFirmwarePerms */
-         {
-             0u,
-             0u,
-         },  
-         /* Pointer: paLutPerms */
-         &rmPaLutPerms[0],
-     }
- };
- /** @brief Global Variable (should be local per DSP) containing LLD RM permission checkers */
- Rm_LldPermCallouts rmPermissionCheckers = 
++            allocators->nextAllocator = newAllocator;
++        }
++        else {
++            rmInst->allocators = newAllocator;
++        }
++    }
++    return (newAllocator);
++}
++
++/* FUNCTION PURPOSE: Deletes a resource allocator
++ ***********************************************************************
++ * DESCRIPTION: Deletes a resource allocator based on the given
++ *              resource name.  The resource allocator will be
++ *              removed from the RM instance allocator list.
++ */
++static int32_t allocatorDelete(Rm_Inst *rmInst, char *resourceName)
 +{
-     Rm_initPermissionChecker,
-     Rm_usePermissionChecker,
- };
++    Rm_Allocator *allocator = rmInst->allocators;
++    Rm_Allocator *prevAllocator = NULL;
++    int32_t       retVal = RM_OK;
 +
- /** @brief Global Variable which describes the RM LLD Version Information */
- const char   rmLldVersionStr[] = RM_LLD_VERSION_STR ":" __DATE__  ":" __TIME__;
++    while (allocator) {
++        if (strncmp(allocator->resourceName, resourceName, RM_NAME_MAX_CHARS) == 0) {
++            break;             
++        }
++        prevAllocator = allocator;
++        allocator = allocator->nextAllocator;
++    }
 +
- /**********************************************************************
-  ********************** Internal Functions *********************************
-  **********************************************************************/
++    if (allocator) {
++        if (prevAllocator == NULL) {
++            rmInst->allocators = allocator->nextAllocator;
++        }
++        else {
++            prevAllocator->nextAllocator = allocator->nextAllocator;
++        }
++        Rm_osalFree((void *)allocator, sizeof(Rm_Allocator));
++    }
++    else {
++        retVal = RM_ERROR_RES_ALLOCATOR_DOES_NOT_EXIST;
++    }
++    return (retVal);
++}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      Initialize the permission tables.  All resources are intialized to deny all initialization
-  *      and usage permissions.
-  *
++/* FUNCTION PURPOSE: Adds an owner to an allocator resource
++ ***********************************************************************
++ * DESCRIPTION: Adds a RM instance node to a resource node's
++ *              list of owners.
 + */
- void Rm_permissionTableInit(void)
++static void addOwner(Rm_ResourceNode *node, void *serviceInstNode)
 +{
-     uint16_t resourceIndex;
-     Rm_Perms *resArrayPtr;
-     uint16_t dmaNum;
-     uint16_t dmaTxCh[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_TX_CH, 
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                           RM_CPPI_AIF_TX_CH,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                           RM_CPPI_FFTC_A_TX_CH, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                           RM_CPPI_FFTC_B_TX_CH, 
- #endif    
- #ifdef QMSS_MAX_PASS_QUEUE
-                                           RM_CPPI_PASS_TX_CH, 
- #endif
-                                           RM_CPPI_QMSS_TX_CH,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                           RM_CPPI_FFTC_C_TX_CH,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                           RM_CPPI_BCP_TX_CH
- #endif                                                                       
-                                          };
-     uint16_t dmaRxCh[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_RX_CH,
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                           RM_CPPI_AIF_RX_CH,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                           RM_CPPI_FFTC_A_RX_CH, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                           RM_CPPI_FFTC_B_RX_CH, 
- #endif                                                               
- #ifdef QMSS_MAX_PASS_QUEUE
-                                           RM_CPPI_PASS_RX_CH, 
- #endif                                          
-                                           RM_CPPI_QMSS_RX_CH,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                           RM_CPPI_FFTC_C_RX_CH,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                           RM_CPPI_BCP_RX_CH
- #endif       
-                                          };
-     uint16_t dmaFlow[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_FLOW, 
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                           RM_CPPI_AIF_FLOW,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                           RM_CPPI_FFTC_A_FLOW, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                           RM_CPPI_FFTC_B_FLOW, 
- #endif                                                         
- #ifdef QMSS_MAX_PASS_QUEUE
-                                           RM_CPPI_PASS_FLOW, 
- #endif                                          
-                                           RM_CPPI_QMSS_FLOW,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                           RM_CPPI_FFTC_C_FLOW,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                           RM_CPPI_BCP_FLOW
- #endif       
-                                          };
-     /* QMSS Linking RAM Control */
-     rmGPermsObj.obj.qmssLinkRamControlPerms.initPerms = 0;
-     rmGPermsObj.obj.qmssLinkRamControlPerms.usePerms = 0;
-     /* QMSS QOS PDSP Timer */
-     rmGPermsObj.obj.qmssQosPdspTimerPerms.initPerms = 0;
-     rmGPermsObj.obj.qmssQosPdspTimerPerms.usePerms = 0;
-     /* PA Firmware */
-     rmGPermsObj.obj.paFirmwarePerms.initPerms = 0;
-     rmGPermsObj.obj.paFirmwarePerms.usePerms = 0;
-     /* Writeback the values that were initialized in the global object itself */
-     Rm_osalEndMemAccess ((void *) &rmGPermsObj, sizeof (Rm_GlobalPermissionsObj));
-     /* QMSS PDSP Firmware */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_FIRMWARE_PDSPS; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssPdspFirmwarePerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssPdspFirmwarePerms[resourceIndex].usePerms = 0;
++    Rm_Owner *ownerList = node->ownerList;
++    Rm_Owner *newOwner = NULL;
++
++    newOwner = Rm_osalMalloc(sizeof(Rm_Owner));
++
++    if (newOwner) {
++        newOwner->instNameNode = serviceInstNode;
++        newOwner->nextOwner = NULL;  
++
++        /* Add owner entry to end of list */
++        if (ownerList) {
++            while (ownerList->nextOwner) {
++                ownerList = ownerList->nextOwner;
++            }
++            ownerList->nextOwner = newOwner;
++        }
++        else {
++            node->ownerList = newOwner;
++        }
++
++        node->allocationCount++;
++        newOwner->instNameNode->allocRefCount++;
 +    }
-     /* Writeback the qmssPdspFirmwarePerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssPdspFirmwarePerms, sizeof (Rm_Perms)*RM_QMSS_FIRMWARE_PDSPS);
++}
 +
-     /* QMSS queues */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_QUEUES; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssQueuePerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssQueuePerms[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Checks a resource node's ownership
++ ***********************************************************************
++ * DESCRIPTION: Returns TRUE if the provided instance node is
++ *              in the list of resource node owners.  Otherwise,
++ *              returns FALSE.
++ */
++static bool isOwnedBy(Rm_ResourceNode *node, void *serviceInstNode)
++{
++    Rm_Owner *owner = node->ownerList;
++
++    while (owner) {
++        if (owner->instNameNode == serviceInstNode) {
++            return(true);           
++        }
++        owner = owner->nextOwner;
 +    }
-     /* Writeback the qmssQueuePerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssQueuePerms, sizeof (Rm_Perms)*RM_QMSS_QUEUES);
++    return(false);
++}
 +
-     /* QMSS memory regions */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_MEM_REGIONS; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssMemRegionPerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssMemRegionPerms[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Compares two resource node's owners
++ ***********************************************************************
++ * DESCRIPTION: Returns TRUE if the owners of two resource nodes 
++ *              are equivalent.  Otherwise, returns FALSE.
++ */
++static bool compareResourceNodeOwners(Rm_ResourceNode *node1, Rm_ResourceNode *node2)
++{
++    Rm_Owner *node1Owners = node1->ownerList;
++    Rm_Owner *node2Owners = node2->ownerList;
++    bool      matchedInst;
++
++    if (node1->allocationCount == node2->allocationCount) {
++        while (node1Owners) {
++            matchedInst = false;
++            while (node2Owners) {
++                if (node1Owners->instNameNode == node2Owners->instNameNode) {
++                    matchedInst = true;
++                    break;
++                }
++                node2Owners = node2Owners->nextOwner;
++            }
++
++            if (matchedInst) {
++                node2Owners = node2->ownerList;
++                node1Owners = node1Owners->nextOwner;
++            }
++            else {
++                return(false);
++            }                
++        }
 +    }
-     /* Writeback the qmssMemRegionPerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssMemRegionPerms, sizeof (Rm_Perms)*RM_QMSS_MEM_REGIONS);
++    else {
++        return(false);
++    }  
++    
++    return(true);
++}
 +
-     /* QMSS Linking RAM */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_LINKING_RAM_RANGES; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssLinkRamPerms[resourceIndex].startIndex = RM_QMSS_LINKING_RAM_RANGE_INIT;
-         rmGPermsObj.obj.qmssLinkRamPerms[resourceIndex].endIndex = RM_QMSS_LINKING_RAM_RANGE_INIT;
-         rmGPermsObj.obj.qmssLinkRamPerms[resourceIndex].rangePerms.initPerms = 0;
-         rmGPermsObj.obj.qmssLinkRamPerms[resourceIndex].rangePerms.usePerms = 0;
++/* FUNCTION PURPOSE: Deletes an owner from an allocator resource
++ ***********************************************************************
++ * DESCRIPTION: Removes a RM instance node from a resource node's
++ *              list of owners.
++ */
++static void deleteOwner(Rm_ResourceNode *node, void *serviceInstNode)
++{
++    Rm_Owner *owner = node->ownerList;
++    Rm_Owner *prevOwner = NULL;
++
++    while (owner) {
++        if (owner->instNameNode == serviceInstNode) {
++            break;             
++        }
++        prevOwner = owner;
++        owner = owner->nextOwner;
 +    }
-     /* Writeback the qmssLinkRamPerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssLinkRamPerms, sizeof (Rm_Perms)*RM_QMSS_LINKING_RAM_RANGES);
 +
-     /* QMSS accumulator channels */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_ACCUM_CH; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssAccumChPerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssAccumChPerms[resourceIndex].usePerms = 0;
++    if (prevOwner == NULL) {
++        node->ownerList = owner->nextOwner;
 +    }
-     /* Writeback the qmssAccumChPerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssAccumChPerms, sizeof (Rm_Perms)*RM_QMSS_ACCUM_CH);
++    else {
++        prevOwner->nextOwner = owner->nextOwner;
++    }
++    
++    node->allocationCount--;
++    owner->instNameNode->allocRefCount--;
++    Rm_osalFree((void *)owner, sizeof(Rm_Owner));
++}
 +
-     /* QMSS QOS Clusters */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_QOS_CLUSTER; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssQosClusterPerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssQosClusterPerms[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Copies the owners of a resource node
++ ***********************************************************************
++ * DESCRIPTION: Creates a list of resource owners for the destination
++ *              resource node that is equivalent to the the 
++ *              source resource node's owners
++ */
++static void copyOwners(Rm_ResourceNode *dstNode, Rm_ResourceNode *srcNode)
++{
++    Rm_Owner *srcOwnerList = srcNode->ownerList;
++    Rm_Owner *dstNewOwner;
++    Rm_Owner *dstPrevOwner;
++
++    dstNode->allocationCount = srcNode->allocationCount;
++
++    while (srcOwnerList) {
++        dstNewOwner = Rm_osalMalloc(sizeof(Rm_Owner));
++        dstNewOwner->instNameNode = srcOwnerList->instNameNode;
++        dstNewOwner->nextOwner = NULL;
++
++        if (dstNode->ownerList == NULL) {
++            dstNode->ownerList = dstNewOwner;
++        }
++        else {
++            dstPrevOwner->nextOwner = dstNewOwner;
++        }
++        dstPrevOwner = dstNewOwner;
++        srcOwnerList = srcOwnerList->nextOwner;
 +    }
-     /* Writeback the qmssQosClusterPerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssQosClusterPerms, sizeof (Rm_Perms)*RM_QMSS_QOS_CLUSTER);    
++}
 +
-     /* QMSS QOS Queues */
-     for (resourceIndex = 0; resourceIndex < RM_QMSS_QOS_QUEUES; resourceIndex++)
-     {
-         rmGPermsObj.obj.qmssQosQueuePerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.qmssQosQueuePerms[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Clears a resource node's owners
++ ***********************************************************************
++ * DESCRIPTION: Deletes all owners from the owners list of a 
++ *              resource node.
++ */
++static void clearOwners(Rm_ResourceNode *node)
++{
++    Rm_Owner *owner = node->ownerList;
++    Rm_Owner *nextOwner;
++
++    while (owner) {
++        nextOwner = owner->nextOwner;
++        node->allocationCount--;
++        Rm_osalFree((void *)owner, sizeof(Rm_Owner));
++        owner = nextOwner;
 +    }
-     /* Writeback the qmssQosQueuePerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssQosQueuePerms, sizeof (Rm_Perms)*RM_QMSS_QOS_QUEUES);      
++}
 +
-     /* CPPI DMA transmit channels */
-     for (dmaNum = 0; dmaNum < RM_CPPI_MAX_DMAS; dmaNum++)
-     {
-         resArrayPtr = rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[dmaNum];
-         
-         for (resourceIndex = 0; resourceIndex < dmaTxCh[dmaNum]; resourceIndex++)
-         {
-             resArrayPtr[resourceIndex].initPerms = 0;
-             resArrayPtr[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Creates a new resource tree
++ ***********************************************************************
++ * DESCRIPTION: Creates a new resource tree using the provided
++ *              resource name and value range.  The name and value
++ *              typically originate from the GRL.
++ */
++static int32_t createResourceTree(Rm_Inst *rmInst, const char *resourceName, Rm_ResourceRange *range)
++{
++    Rm_Allocator    *allocator = NULL;
++    Rm_ResourceTree *treeRootEntry = NULL;
++    Rm_ResourceNode *treeNode = NULL;
++    Rm_ResourceNode *collidingNode = NULL;
++
++    allocator = allocatorAdd(rmInst, resourceName);
++    treeRootEntry = Rm_osalMalloc(sizeof(Rm_ResourceTree));
++    RB_INIT(treeRootEntry);
++
++    while (range != NULL) {
++        treeNode = rmResourceNodeNew(range->base, range->length);
++        collidingNode = RB_INSERT(_Rm_AllocatorResourceTree, treeRootEntry, treeNode);
++
++        if (collidingNode) {
++            Rm_ResourceNode *nextNode = NULL;
++            
++            /* Node that was inserted collides with existing node.  Destroy tree and return error */
++            for (treeNode = RB_MIN(_Rm_AllocatorResourceTree, treeRootEntry); treeNode != NULL; treeNode = nextNode) {
++                      nextNode = RB_NEXT(_Rm_AllocatorResourceTree, treeRootEntry, treeNode);
++                      RB_REMOVE(_Rm_AllocatorResourceTree, treeRootEntry, nextNode);
++                rmResourceNodeFree(treeNode);
++              }
++            Rm_osalFree((void *)treeRootEntry, sizeof(Rm_ResourceTree));
++            allocatorDelete(rmInst, allocator->resourceName);
++            return (RM_ERROR_GRL_RES_SPECIFIED_MORE_THAN_ONCE);
 +        }
++        range = range->nextRange;
++    }
++    
++    allocator->allocatorRootEntry = treeRootEntry;
++    return(RM_OK);
++}
++
++/* FUNCTION PURPOSE: Preallocates a resource
++ ***********************************************************************
++ * DESCRIPTION: Called when an allocate request is made but the base 
++ *              is unspecified.  The preallocation algorithm looks at 
++ *              available resources as well as policy permissions to 
++ *              determine a resource range that satisfies the request.
++ *              If a valid range is found it will be returned for the 
++ *              treeAllocate algorithm to handle.
++ */
++static int32_t treePreAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourcePolicy,
++                               Rm_AllocatorOpInfo *opInfo)
++{
++    Rm_ResourceNode    findNode;
++    Rm_ResourceNode   *matchingNode = NULL;
++    uint32_t           matchingEnd;
++    uint32_t           rangeIndex;
++    bool               resourceFound = false;
++    Rm_PolicyCheckType policyCheckType;
++    Rm_PolicyCheckCfg  policyCheckCfg;
++    bool               nodePassesPolicy;
++    int32_t            retVal = RM_SERVICE_PROCESSING;    
++
++    opInfo->resourceInfo->base = rmPolicyGetResourceBase(rmInst->policy, opInfo->serviceSrcInstNode, 
++                                                          resourcePolicy, opInfo->allocType, 
++                                                          &retVal);
++    if (retVal != RM_SERVICE_PROCESSING) {
++        return (retVal);
++    }
 +
-         /* Writeback each of the transmit channel arrays  */
-         Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaTxCh[dmaNum]);
++    if (opInfo->resourceInfo->alignment == RM_RESOURCE_ALIGNMENT_UNSPECIFIED) {  
++        /* Get alignment from policy */
++        opInfo->resourceInfo->alignment = rmPolicyGetResourceAlignment(rmInst->policy, resourcePolicy);
 +    }
++    
++    if (opInfo->resourceInfo->alignment == 0) {
++        opInfo->resourceInfo->alignment = 1;
++    }    
 +
-     /* CPPI DMA receive channels */
-     for (dmaNum = 0; dmaNum < RM_CPPI_MAX_DMAS; dmaNum++)
-     {
-         resArrayPtr = rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[dmaNum];
++    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));
++    findNode.base = opInfo->resourceInfo->base;
++    findNode.length = opInfo->resourceInfo->length;
++
++    /* Configure policy checking structure */
++    memset((void *)&policyCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
++    if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_INIT_SHIFT)) {
++        policyCheckType = Rm_policyCheck_INIT;
++    }
++    else if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_USE_SHIFT)) {
++        policyCheckType = Rm_policyCheck_USE;
++    }
++    policyCheckCfg.policyDtb = rmInst->policy;
++    policyCheckCfg.resourceOffset = resourcePolicy;
++    
++    do {
++        matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);
 +        
-         for (resourceIndex = 0; resourceIndex < dmaRxCh[dmaNum]; resourceIndex++)
-         {
-             resArrayPtr[resourceIndex].initPerms = 0;
-             resArrayPtr[resourceIndex].usePerms = 0;
++        if (matchingNode) {
++            nodePassesPolicy = false;
++            policyCheckCfg.type = policyCheckType;
++            policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;
++            policyCheckCfg.resourceBase = findNode.base;
++            policyCheckCfg.resourceLength = findNode.length;
++            nodePassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);    
++            
++            if (nodePassesPolicy && (matchingNode->allocationCount > 0)) {
++                /* Check exclusive privileges of instance requesting resource.  Requesting
++                 * instance with exclusive privileges can't reserve resource if already owned*/
++                policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
++                policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;
++                nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);
++            }
++            
++            if (nodePassesPolicy && (matchingNode->allocationCount == 1)) {
++                /* Check exclusive privileges of instance that currently owns resource */
++                policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
++                policyCheckCfg.validInstNode = matchingNode->ownerList->instNameNode;
++                nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);
++            }
++
++            if (retVal != RM_SERVICE_PROCESSING) {
++                break;
++            }
++
++            if (nodePassesPolicy) {
++                matchingEnd = matchingNode->base + matchingNode->length - 1;
++                /* Initialize indexer to be first resource value that alignment */
++                rangeIndex = findNode.base;
++                if (rangeIndex % opInfo->resourceInfo->alignment) {
++                    rangeIndex += (opInfo->resourceInfo->alignment -
++                                  (rangeIndex % opInfo->resourceInfo->alignment));
++                }
++                
++                if ((rangeIndex + opInfo->resourceInfo->length - 1) <= matchingEnd) {
++                    /* Block of unallocated resources within matchingNode that satisfies
++                     * allocate requirements */
++                    opInfo->resourceInfo->base = rangeIndex;
++                    resourceFound = true;
++                }     
++            }
++            
++            if (!resourceFound) {
++                /* Check next resource node for available resources */
++                findNode.base = matchingNode->base + matchingNode->length;
++            }
 +        }
++        else {
++            retVal = RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET;
++        }
++    } while ((!resourceFound) && 
++             (retVal != RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET));
 +
-         /* Writeback each of the receive channel arrays */
-         Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaRxCh[dmaNum]);
-     }    
++    return(retVal); 
++}
 +
-     /* CPPI DMA flows */
-     for (dmaNum = 0; dmaNum < RM_CPPI_MAX_DMAS; dmaNum++)
-     {
-         resArrayPtr = rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[dmaNum];
++/* FUNCTION PURPOSE: Allocates a resource
++ ***********************************************************************
++ * DESCRIPTION: Will attempt to allocate the resource with specified
++ *              base and length from the resource's allocator.  The
++ *              allocation algorithm will verify the allocation against
++ *              the policy permissions for the instance requesting the
++ *              allocation.  If the policy allows the allocation the 
++ *              algorithm will allocate the resource then combine any
++ *              resource nodes that may have become equivalent (in terms
++ *              of ownership) after the allocation.
++ */
++static int32_t treeAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourcePolicy,
++                            Rm_AllocatorOpInfo *opInfo)
++{
++    Rm_ResourceNode     findNode;
++    Rm_ResourceNode    *matchingNode = NULL;
++    Rm_ResourceNode    *leftNode = NULL;
++    Rm_ResourceNode    *rightNode = NULL;
++    Rm_PolicyCheckType  policyCheckType;    
++    Rm_PolicyCheckCfg   policyCheckCfg;
++    bool                allocPassesPolicy;
++    bool                combineLeft = false;
++    bool                combineRight = false;    
++    uint32_t            findEnd;
++    uint32_t            matchingEnd;  
++    int32_t             retVal = RM_SERVICE_PROCESSING;
++
++    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));
++    findNode.base = opInfo->resourceInfo->base;
++    findNode.length = opInfo->resourceInfo->length;
++    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);
++
++    /* Prepare privilege checks */
++    memset((void *)&policyCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
++    if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_INIT_SHIFT)) {
++        policyCheckType = Rm_policyCheck_INIT;
++    }
++    else if (RM_policy_GET_PERM(opInfo->allocType, RM_POLICY_PERM_USE_SHIFT)) {
++        policyCheckType = Rm_policyCheck_USE;
++    }
++
++    if (matchingNode) {
++        findEnd = findNode.base + findNode.length - 1;
++        matchingEnd = matchingNode->base + matchingNode->length - 1;
 +        
-         for (resourceIndex = 0; resourceIndex < dmaFlow[dmaNum]; resourceIndex++)
-         {
-             resArrayPtr[resourceIndex].initPerms = 0;
-             resArrayPtr[resourceIndex].usePerms = 0;
++        if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {
++            if (opInfo->serviceSrcInstNode == rmPolicyGetLinuxInstNode(rmInst->validInstances)) {
++                /* Bypass policy checks since Linux Kernel has full privileges */
++                allocPassesPolicy = true;
++            }
++            else {
++                policyCheckCfg.policyDtb = rmInst->policy;
++                policyCheckCfg.resourceOffset = resourcePolicy;    
++                policyCheckCfg.type = policyCheckType;
++                policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;
++                policyCheckCfg.resourceBase = findNode.base;
++                policyCheckCfg.resourceLength = findNode.length;
++                allocPassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);
++                if (!allocPassesPolicy) {
++                    if (policyCheckType == Rm_policyCheck_INIT) {
++                        retVal = RM_SERVICE_DENIED_INIT_PERM_NOT_GIVEN;
++                    }
++                    else {
++                        retVal = RM_SERVICE_DENIED_USE_PERM_NOT_GIVEN;
++                    }
++                }
++
++                if (!isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {
++                    /* Perform exclusive checks if requesting instance does not already an
++                     * owner of the resource */
++                    if (allocPassesPolicy && (matchingNode->allocationCount > 0)) {
++                        /* Check exclusive privileges of instance requesting resource.  Requesting
++                         * instance with exclusive privileges can't reserve resource if already owned*/
++                        policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
++                        policyCheckCfg.validInstNode = opInfo->serviceSrcInstNode;
++                        allocPassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);
++                        if (!allocPassesPolicy) {
++                            retVal = RM_SERVICE_DENIED_EXCLUSIVE_RES_ALLOCD;
++                        }
++                    }
++                    if (allocPassesPolicy && (matchingNode->allocationCount == 1)) {
++                        /* Check exclusive privileges of instance that currently owns resource */
++                        policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
++                        policyCheckCfg.validInstNode = matchingNode->ownerList->instNameNode;
++                        allocPassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg, &retVal);
++                        if (!allocPassesPolicy) {
++                            retVal = RM_SERVICE_DENIED_ALLOCD_TO_EXCLUSIVE_INST;
++                        }                
++                    }  
++                }
++            }
++            
++            if (allocPassesPolicy) {
++                if (!isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {
++                    /* Handle any possible node combinations if requesting instance is
++                     * not already in resource's owner list.  Automatic approval if requesting
++                     * instance is already in owner list. */
++                    if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd)) {
++                        /* findNode range matches matchingNode range
++                         *
++                         *   |<--left node-->||<--matched  node-->||<--right node-->| => existing node
++                         *                    |<--alloc request-->|  => requested resources
++                         */                     
++                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        addOwner(matchingNode, opInfo->serviceSrcInstNode);
++
++                        if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                            combineLeft = true;
++                        }
++                        if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                            combineRight = true;
++                        }
++
++                        if (combineLeft && combineRight) {
++                            /* Combine all three nodes into matchingNode */
++                            matchingNode->base = leftNode->base;
++                            matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;
++
++                            clearOwners(leftNode);
++                            rmResourceNodeFree(leftNode);
++                            clearOwners(rightNode);
++                            rmResourceNodeFree(rightNode);                        
++                        }
++                        else if (combineLeft) {
++                            /* Combine left and matching nodes.  Reinsert right. */
++                            matchingNode->base = leftNode->base;
++                            matchingNode->length += leftNode->length;
++
++                            clearOwners(leftNode);
++                            rmResourceNodeFree(leftNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);                        
++                        }
++                        else if (combineRight) {
++                            /* Combine right and matching nodes.  Reinsert left. */
++                            matchingNode->length += rightNode->length;
++
++                            clearOwners(rightNode);
++                            rmResourceNodeFree(rightNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        }
++                        else {
++                            /* No combine. */
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                        }
++
++                        /* Always reinsert matchingNode */                
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);   
++                    }   
++                    else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {
++                        /* findNode range is subset of matchingNode range and neither boundary is
++                         * equivalent.
++                         *
++                         * |<----------matched node---------->|
++                         *        |<---alloc request--->|
++                         */ 
++                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);
++                        copyOwners(leftNode, matchingNode);
++                        rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);
++                        copyOwners(rightNode, matchingNode);
++
++                        matchingNode->base = findNode.base;                                    
++                        matchingNode->length = findNode.length;
++                        addOwner(matchingNode, opInfo->serviceSrcInstNode);
++
++                        /* Insert all the nodes */
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                    }  
++                    else {    
++                        if (findNode.base == matchingNode->base) {
++                            /* findNode base and matchingNode base are equivalent.  May be combine
++                             * possibilities to the left
++                             *
++                             * |<---left node (alloc'd)--->||<----------matched node---------->|
++                             *                              |<---findNode (alloc req)--->|
++                             */                         
++                            leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            /* Add allocating instance to owner list for compare with leftNode */
++                            addOwner(matchingNode, opInfo->serviceSrcInstNode);
++                            
++                            if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {
++                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                                /* Combine leftNode and findNode */
++                                leftNode->length += findNode.length;
++                            }
++                            else {
++                                leftNode = rmResourceNodeNew(findNode.base, findNode.length);
++                                copyOwners(leftNode, matchingNode);
++                            }
++
++                            /* Account for leftNode in matchingNode */
++                            matchingNode->base = findNode.base + findNode.length;
++                            matchingNode->length = matchingEnd - findEnd;  
++
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        }
++                        else if (findEnd == matchingEnd) {
++                            /* findNode end and matchingNode end are equivalent.  May be combine
++                             * possibilities to the right
++                             *
++                             * |<----------matched node---------->||<---right node (alloc'd)--->|
++                             *       |<---findNode (alloc req)--->| 
++                             */                        
++                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            /* Add allocating instance to owner list for compare with rightNode */
++                            addOwner(matchingNode, opInfo->serviceSrcInstNode);
++                            
++                            if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {
++                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                                /* Combine rightNode and findNode */
++                                rightNode->base = findNode.base;
++                                rightNode->length += findNode.length;
++                            }
++                            else {
++                                rightNode = rmResourceNodeNew(findNode.base, findNode.length);
++                                copyOwners(rightNode, matchingNode);
++                            }
++
++                            /* Account for rightNode in matchingNode */
++                            matchingNode->length -= findNode.length;  
++
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                        }
++                        /* Remove allocating instance from leftover matchingNode */
++                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                    }
++                }
++                retVal = RM_SERVICE_APPROVED;
++            }
 +        }
++        else {
++            retVal = RM_SERVICE_DENIED_PARTIAL_ALLOCATION;
++        }
++    }
++    else {
++        retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;
++    }
 +
-         /* Writeback each of the flow arrays */
-         Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaFlow[dmaNum]);
-     }       
++    return(retVal);        
++}
 +
-     /* PA Lookup tables */
-     for (resourceIndex = 0; resourceIndex < RM_PA_LUT; resourceIndex++)
-     {
-         rmGPermsObj.obj.paLutPerms[resourceIndex].initPerms = 0;
-         rmGPermsObj.obj.paLutPerms[resourceIndex].usePerms = 0;
++/* FUNCTION PURPOSE: Frees a resource
++ ***********************************************************************
++ * DESCRIPTION: Will attempt to free the resource with specified
++ *              base and length from the resource's allocator.  The
++ *              free algorithm will verify the free request parameters
++ *              match an allocated range for the resource and that the
++ *              range is owned by the instance requesting the free. If
++ *              the free is validated the algorithm will free the 
++ *              resource then combine any resource nodes that may have
++ *              become equivalent (in terms of ownership) after the
++ *              allocation.
++ */
++static int32_t treeFree(Rm_Allocator *allocator, Rm_AllocatorOpInfo *opInfo)
++{
++    Rm_ResourceNode  findNode;
++    Rm_ResourceNode *matchingNode = NULL;
++    Rm_ResourceNode *leftNode = NULL;
++    Rm_ResourceNode *rightNode = NULL;
++    bool             combineLeft = false;
++    bool             combineRight = false;
++    uint32_t         findEnd;
++    uint32_t         matchingEnd;
++    int32_t          retVal;
++
++    memset((void *)&findNode, 0, sizeof(Rm_ResourceNode));
++    findNode.base = opInfo->resourceInfo->base;
++    findNode.length = opInfo->resourceInfo->length;
++    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, &findNode);
++
++    if (matchingNode) {
++        findEnd = findNode.base + findNode.length - 1;
++        matchingEnd = matchingNode->base + matchingNode->length - 1;
++        
++        if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {  
++            if (matchingNode->allocationCount) {
++                if (isOwnedBy(matchingNode, opInfo->serviceSrcInstNode)) {
++                    if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd))
++                    {
++                        /* Case 1: Free range equals allocated matched node exactly. Attempt to combine 
++                         *         freed node with nodes to left and right.
++                         *
++                         * |<--left node-->||<---matched node--->||<--right node-->|
++                         *                  |<---free request--->|
++                         */ 
++                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);
++
++                        if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                            combineLeft = true;
++                        }
++                        if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                            combineRight = true;
++                        }
++
++                        if (combineLeft && combineRight) {
++                            /* Combine all three nodes into matchingNode */
++                            matchingNode->base = leftNode->base;
++                            matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;
++
++                            clearOwners(leftNode);
++                            rmResourceNodeFree(leftNode);
++                            clearOwners(rightNode);
++                            rmResourceNodeFree(rightNode);                        
++                        }
++                        else if (combineLeft) {
++                            /* Combine left and matching nodes.  Reinsert right. */
++                            matchingNode->base = leftNode->base;
++                            matchingNode->length += leftNode->length;
++
++                            clearOwners(leftNode);
++                            rmResourceNodeFree(leftNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);                        
++                        }
++                        else if (combineRight) {
++                            /* Combine right and matching nodes.  Reinsert left. */
++                            matchingNode->length += rightNode->length;
++
++                            clearOwners(rightNode);
++                            rmResourceNodeFree(rightNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        }
++                        else {
++                            /* No combine. */
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                        }
++
++                        /* Always reinsert matchingNode */
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);                    
++                    }
++                    else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {
++                        /* Case 2: Free range is less than range in matched node. Split
++                         *         matched node into three nodes.
++                         *
++                         * |<----------matched node---------->|
++                         *        |<---free request--->|
++                         *
++                         * Remove instance from AllocatedTo list then add it back in for side nodes for
++                         * proper accounting of allocations in validInstance list
++                         */ 
++                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                        deleteOwner(matchingNode, opInfo->serviceSrcInstNode);
++                        
++                        leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);
++                        copyOwners(leftNode, matchingNode);
++                        addOwner(leftNode, opInfo->serviceSrcInstNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        
++                        rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);
++                        copyOwners(rightNode, matchingNode);
++                        addOwner(rightNode, opInfo->serviceSrcInstNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++
++                        matchingNode->base = findNode.base;                                    
++                        matchingNode->length = findNode.length;
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                    }
++                    else {                        
++                        if (findNode.base == matchingNode->base) {
++                            /* Case 3: Free range is on left boundary of matched node. Try to 
++                             *         combine free range with left node.
++                             *
++                             * |<---left node (free)--->||<----------matched node---------->|
++                             *                           |<---findNode (free req)--->|
++                             */ 
++
++                            leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            /* Remove freeing instance from owner list for compare with leftNode */
++                            deleteOwner(matchingNode, opInfo->serviceSrcInstNode);
++                            
++                            if (leftNode && compareResourceNodeOwners(leftNode, matchingNode)) {
++                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                                /* Combine leftNode and findNode */
++                                leftNode->length += findNode.length;
++                            }
++                            else {
++                                leftNode = rmResourceNodeNew(findNode.base, findNode.length);
++                                copyOwners(leftNode, matchingNode);
++                            }
++
++                            /* Remove leftNode range from matchingNode */
++                            matchingNode->base = findNode.base + findNode.length;
++                            matchingNode->length = matchingEnd - findEnd;  
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, leftNode);
++                        }
++                        else if (findEnd == matchingEnd) {
++                            /* Case 4: Free range is on right boundary of matched node. Try to 
++                             *         combine free range with right node.
++                             *
++                             * |<----------matched node---------->||<---right node (free)--->|
++                             *        |<---findNode (free req)--->|
++                             */ 
++                            
++                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode); 
++                            /* Remove freeing instance from owner list for compare with rightNode */
++                            deleteOwner(matchingNode, opInfo->serviceSrcInstNode);
++                            
++                            if (rightNode && compareResourceNodeOwners(rightNode, matchingNode)) {
++                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                                /* Combine rightNode and findNode */
++                                rightNode->base = findNode.base;
++                                rightNode->length += findNode.length;
++                            }
++                            else {
++                                rightNode = rmResourceNodeNew(findNode.base, findNode.length);
++                                copyOwners(rightNode, matchingNode);
++                            }
++
++                            /* Remove rightNode range from matchingNode */
++                            matchingNode->length -= findNode.length;  
++                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, rightNode);
++                        }
++
++                        /* Add freeing instance back into matchingNode allocations */
++                        addOwner(matchingNode, opInfo->serviceSrcInstNode);
++                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->allocatorRootEntry, matchingNode);
++                    }
++
++                    retVal = RM_SERVICE_APPROVED;
++                }
++                else {
++                    retVal = RM_SERVICE_DENIED_RES_NOT_ALLOCD_TO_INST;
++                }
++            }
++            else {
++                retVal = RM_SERVICE_DENIED_RES_ALREADY_FREE;
++            }
++        }
++        else {
++            retVal = RM_SERVICE_DENIED_PARTIAL_FREE;
++        }
 +    }
-     /* Writeback the paLutPerms array */
-     Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.paLutPerms, sizeof (Rm_Perms)*RM_PA_LUT);
-     
++    else {
++        retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;
++    }
++    return(retVal);  
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      Sets a list of entries in a permissions array to the specified permissions
-  *
-  *  @param[in]  resourceEntry
-  *      The resource entry from the application defined resource table containing
-  *      a range of resources and the permissions to assign to them.
-  *
-  *  @param[in]  rmPermsArray
-  *      The permissions array for the resource specified in the resourceEntry.
-  *     
-  *  @param[in]  len
-  *      Full length of permissions array for writeback after the permissions have been
-  *      transferred.
++/* FUNCTION PURPOSE: Issues a service response to application
++ ***********************************************************************
++ * DESCRIPTION: Provides a service response back to the application
++ *              using the service callback function provided to
++ *              the RM instance at the time of the service request.
 + */
- void Rm_setTablePermissions (const Rm_Resource *resourceEntry, Rm_Perms *rmPermsArray, uint32_t len)
++static void serviceResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
 +{
-     uint32_t index;
-     /* Scan through the resource range filling in the specified permission */
-     for (index = resourceEntry->resourceStart; index < resourceEntry->resourceEnd + 1; index++)
++    Rm_ServiceRespInfo serviceResponse;
++
++    /* The responseTransaction will contain the resultant state details of
++     * the requestTransaction's service request */
++    serviceResponse.serviceState = transaction->state;
++    /* Pass back the ID that was provided to the component when it requested
++     * the service */
++    serviceResponse.serviceId = transaction->localId;
++
++    /* Service was approved and service was an allocate request.  The resource
++     * data is passed back to the component */
++    if ((serviceResponse.serviceState == RM_SERVICE_APPROVED) &&
++        ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
++         (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
++         (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))
 +    {
-         rmPermsArray[index].initPerms = resourceEntry->resourceInitFlags;
-         rmPermsArray[index].usePerms  = resourceEntry->resourceUseFlags;
++        strncpy(serviceResponse.resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
++        serviceResponse.resourceBase = transaction->resourceInfo.base;
++        serviceResponse.resourceLength = transaction->resourceInfo.length;
 +    }
 +
-     Rm_osalEndMemAccess ((void *)rmPermsArray, sizeof (Rm_Perms)* len);
++    /* Issue the callback to the requesting component with the response information */
++    transaction->callback.serviceCallback(&serviceResponse);
++
++    /* Delete the transaction from the transaction queue */
++    rmTransactionQueueDelete(rmInst, transaction->localId);
++    return;
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      Takes an application specified resource table as input and transfers all
-  *      resource permissions specified within into the internal resource
-  *      permission tables.  Upon completion of permission transfer a global
-  *      synchronization object is written to sync with slave cores.
-  *
-  *  @param[in]  rmResourceTable
-  *      Application defined resource table containing all resources that should
-  *      have permissions set for the DSPs
-  *
-  *  @retval
-  *      Success -   RM_OK
-  *  @retval
-  *      Failure -   RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED
++/* FUNCTION PURPOSE: Sends RM response packets
++ ***********************************************************************
++ * DESCRIPTION: Sends RM response packets to RM instance's that sent
++ *              RM request packets to the RM instance.  The response
++ *              is sent via the RM transport API which is plugged
++ *              with an application created transport path.
 + */
- Rm_Result Rm_populatePermissionTable(const Rm_Resource *rmResourceTable)
++static void transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
 +{
-     const Rm_Resource *resourceEntry;
-     uint16_t linkRamIndex;
++    Rm_Transport    *dstTransport = NULL;
++    Rm_PacketHandle  pktHandle = NULL;
++
++    dstTransport = rmTransportFindRemoteName((Rm_Transport *) rmInst->transports, transaction->pktSrcInstName);
++
++    switch (transaction->type) {
++        case Rm_service_RESOURCE_ALLOCATE_INIT:
++        case Rm_service_RESOURCE_ALLOCATE_USE:
++        case Rm_service_RESOURCE_FREE:
++        case Rm_service_RESOURCE_GET_BY_NAME:
++            pktHandle = rmTransportCreateResourceResponsePkt(rmInst, dstTransport->appTransportHandle, 
++                                                             transaction);
++            break;
++        case Rm_service_RESOURCE_MAP_TO_NAME:
++        case Rm_service_RESOURCE_UNMAP_NAME:
++            pktHandle = rmTransportCreateNsResponsePkt(rmInst, dstTransport->appTransportHandle,
++                                                       transaction);
++            break;
++    }
 +
-     /* Verify resource table can be read by verifying magic number is contained
-      * in first entry of the resource table */
-     resourceEntry = rmResourceTable;
-     
-     /* Invalidate the resource */
-     Rm_osalBeginMemAccess ((void *) resourceEntry, sizeof (Rm_Resource));
-     if (resourceEntry->resourceId != RM_RESOURCE_MAGIC_NUMBER)
-     {
-         return RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED;
++    if (pktHandle) {
++        if (rmInst->transportCallouts.rmSendPkt) {
++            if (rmInst->transportCallouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {
++                transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;
++            }
++        }
++        else {
++            transaction->state = RM_ERROR_TRANSPORT_SEND_NOT_REGD;
++        }
 +    }
++    rmTransactionQueueDelete(rmInst, transaction->localId);
++}
 +
-     /* Magic number is visible start parsing the resource table and transferring
-       * permissions to the internal permissions tables */
++/* FUNCTION PURPOSE: Sends RM request packets
++ ***********************************************************************
++ * DESCRIPTION: Sends RM request packets to RM instance's that are
++ *              capable of forwarding or validating service requests.
++ *              The request is sent via the RM transport API which is
++ *              plugged with an application created transport path.
++ */
++static void transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction)
++{
++    Rm_Transport    *dstTransport = NULL;
++    Rm_PacketHandle  pktHandle = NULL;
 +
-     /* Parse resource table until last entry field is encountered */
-     while (resourceEntry->resourceId != RM_RESOURCE_FINAL_ENTRY)
-     {
-         /* Invalidate the resource */
-         Rm_osalBeginMemAccess ((void *) resourceEntry, sizeof (Rm_Resource));
-         /* Populate a permission table based on the resourceId */
-         switch (resourceEntry->resourceId)
-         {
-             case RM_RESOURCE_MAGIC_NUMBER:
-                 break;     
-                 
-             case RM_RESOURCE_QMSS_FIRMWARE_PDSP:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_FIRMWARE_PDSPS, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssPdspFirmwarePerms, RM_QMSS_FIRMWARE_PDSPS);
-                 break;
-             case RM_RESOURCE_QMSS_QUEUE:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_QUEUES, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssQueuePerms, RM_QMSS_QUEUES);
-                 break;
-             case RM_RESOURCE_QMSS_MEMORY_REGION:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_MEM_REGIONS, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssMemRegionPerms, RM_QMSS_MEM_REGIONS);
-                 break;
-                 
-             case RM_RESOURCE_QMSS_LINKING_RAM_CONTROL:
-                 rmGPermsObj.obj.qmssLinkRamControlPerms.initPerms = resourceEntry->resourceInitFlags;
-                 rmGPermsObj.obj.qmssLinkRamControlPerms.usePerms  = resourceEntry->resourceUseFlags;
-                 break;
-                 
-             case RM_RESOURCE_QMSS_LINKING_RAM:
-                 /* Expect Linking RAM ranges to be presented in order */
-                 /* Find next available unused Linking RAM permissions entry */
-                 for (linkRamIndex = 0; linkRamIndex < RM_QMSS_LINKING_RAM_RANGES; linkRamIndex++)
-                 {
-                     if ((rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].startIndex == RM_QMSS_LINKING_RAM_RANGE_INIT) &&
-                          (rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].endIndex == RM_QMSS_LINKING_RAM_RANGE_INIT))
-                     {
-                         RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_LINKING_RAM_RANGE_INIT, 
-                                         RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                         /* Populate the entry with the Linking RAM resource data */
-                         rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].startIndex = resourceEntry->resourceStart;
-                         rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].endIndex = resourceEntry->resourceEnd;
-                         rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].rangePerms.initPerms = resourceEntry->resourceInitFlags;
-                         rmGPermsObj.obj.qmssLinkRamPerms[linkRamIndex].rangePerms.usePerms  = resourceEntry->resourceUseFlags;
-                         Rm_osalEndMemAccess ((void *)&rmGPermsObj.obj.qmssLinkRamPerms[0], sizeof (Rm_Perms)* RM_QMSS_LINKING_RAM_RANGES);
-                         
-                         /* Leave search loop */
-                         break;
-                     }
-                 }
-                 break;
-             case RM_RESOURCE_QMSS_ACCUMULATOR_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_ACCUM_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssAccumChPerms, RM_QMSS_ACCUM_CH);
-                 break;
-             case RM_RESOURCE_QMSS_QOS_PDSP_TIMER:
-                 rmGPermsObj.obj.qmssQosPdspTimerPerms.initPerms = resourceEntry->resourceInitFlags;
-                 rmGPermsObj.obj.qmssQosPdspTimerPerms.usePerms  = resourceEntry->resourceUseFlags;
-                 break;
-             case RM_RESOURCE_QMSS_QOS_CLUSTER:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_QOS_CLUSTER, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssQosClusterPerms, RM_QMSS_QOS_CLUSTER);
-                 break;             
-                 
-             case RM_RESOURCE_QMSS_QOS_QUEUE:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_QMSS_QOS_QUEUES, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.qmssQosQueuePerms, RM_QMSS_QOS_QUEUES);
-                 break;                    
-             case RM_RESOURCE_CPPI_SRIO_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_SRIO_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_SRIO_DMA_ID], RM_CPPI_SRIO_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_SRIO_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_SRIO_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_SRIO_DMA_ID], RM_CPPI_SRIO_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_SRIO_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_SRIO_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_SRIO_DMA_ID], RM_CPPI_SRIO_FLOW);
-                 break;
- #ifdef QMSS_MAX_AIF_QUEUE
-             case RM_RESOURCE_CPPI_AIF_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_AIF_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_AIF_DMA_ID], RM_CPPI_AIF_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_AIF_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_AIF_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_AIF_DMA_ID], RM_CPPI_AIF_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_AIF_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_AIF_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_AIF_DMA_ID], RM_CPPI_AIF_FLOW);
-                 break;            
- #endif
- #ifdef QMSS_MAX_FFTC_A_QUEUE
-             case RM_RESOURCE_CPPI_FFTC_A_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_A_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_FFTC_A_DMA_ID], RM_CPPI_FFTC_A_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_A_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_A_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_FFTC_A_DMA_ID], RM_CPPI_FFTC_A_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_A_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_A_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_FFTC_A_DMA_ID], RM_CPPI_FFTC_A_FLOW);
-                 break;     
- #endif    
- #ifdef QMSS_MAX_FFTC_B_QUEUE
-             case RM_RESOURCE_CPPI_FFTC_B_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_B_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_FFTC_B_DMA_ID], RM_CPPI_FFTC_B_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_B_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_B_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_FFTC_B_DMA_ID], RM_CPPI_FFTC_B_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_B_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_B_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_FFTC_B_DMA_ID], RM_CPPI_FFTC_B_FLOW);
-                 break;       
- #endif                
- #ifdef QMSS_MAX_PASS_QUEUE
-             case RM_RESOURCE_CPPI_PASS_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_PASS_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_PASS_DMA_ID], RM_CPPI_PASS_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_PASS_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_PASS_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_PASS_DMA_ID], RM_CPPI_PASS_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_PASS_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_PASS_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_PASS_DMA_ID], RM_CPPI_PASS_FLOW);
-                 break;
- #endif                
-             case RM_RESOURCE_CPPI_QMSS_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_QMSS_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_QMSS_DMA_ID], RM_CPPI_QMSS_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_QMSS_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_QMSS_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_QMSS_DMA_ID], RM_CPPI_QMSS_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_QMSS_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_QMSS_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_QMSS_DMA_ID], RM_CPPI_QMSS_FLOW);
-                 break;
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-             case RM_RESOURCE_CPPI_FFTC_C_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_C_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_FFTC_C_DMA_ID], RM_CPPI_FFTC_C_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_C_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_C_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_FFTC_C_DMA_ID], RM_CPPI_FFTC_C_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_FFTC_C_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_FFTC_C_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_FFTC_C_DMA_ID], RM_CPPI_FFTC_C_FLOW);
-                 break;          
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-             case RM_RESOURCE_CPPI_BCP_TX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_BCP_TX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[RM_CPPI_BCP_DMA_ID], RM_CPPI_BCP_TX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_BCP_RX_CH:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_BCP_RX_CH, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[RM_CPPI_BCP_DMA_ID], RM_CPPI_BCP_RX_CH);
-                 break;
-             case RM_RESOURCE_CPPI_BCP_FLOW:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_CPPI_BCP_FLOW, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[RM_CPPI_BCP_DMA_ID], RM_CPPI_BCP_FLOW);
-                 break;      
- #endif                
-             case RM_RESOURCE_PA_FIRMWARE:
-                 rmGPermsObj.obj.paFirmwarePerms.initPerms = resourceEntry->resourceInitFlags;
-                 rmGPermsObj.obj.paFirmwarePerms.usePerms  = resourceEntry->resourceUseFlags;
-                 break;
-             case RM_RESOURCE_PA_LUT_ENTRY:
-                 RM_RANGE_CHECK (resourceEntry->resourceStart, resourceEntry->resourceEnd, RM_PA_LUT, RM_ERROR_PERMISSION_TABLE_ENTRY_FAILURE);
-                 Rm_setTablePermissions (resourceEntry, rmGPermsObj.obj.paLutPerms, RM_PA_LUT);
-                 break;
-             default:
-                 return RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED;
++    if (rmInst->registeredWithDelegateOrServer) {
++        if (rmInst->instType == Rm_instType_CLIENT) {
++            dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_CLIENT_DELEGATE);
 +
++            if (!dstTransport) {
++                dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_SERVER);
++            }
++        } 
++        else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
++            dstTransport = rmTransportFindRemoteInstType((Rm_Transport *) rmInst->transports, Rm_instType_SERVER);
 +        }
 +
-         resourceEntry++;
-     };
++        switch (transaction->type) {
++            case Rm_service_RESOURCE_ALLOCATE_INIT:
++            case Rm_service_RESOURCE_ALLOCATE_USE:
++            case Rm_service_RESOURCE_FREE:
++            case Rm_service_RESOURCE_GET_BY_NAME:
++                pktHandle = rmTransportCreateResourceReqPkt(rmInst, dstTransport->appTransportHandle, transaction);
++                break;
++            case Rm_service_RESOURCE_MAP_TO_NAME:
++            case Rm_service_RESOURCE_UNMAP_NAME:
++                pktHandle = rmTransportCreateNsRequestPkt(rmInst, dstTransport->appTransportHandle, transaction);
++                break;
++        }
 +
-     /* Write synchronization object so that slave cores know permissions table is
-       * populated and valid */
-     rmGSyncObj.obj.globalSyncObj = RM_PERMISSION_TABLE_VALID;
-     
-     /* Writeback Sync Object */
-     Rm_osalEndMemAccess ((void *) &rmGSyncObj, sizeof (Rm_Sync_Obj));
++        if (pktHandle) {
++            if (rmInst->transportCallouts.rmSendPkt) {            
++                if (rmInst->transportCallouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {
++                    transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;
++                }
++            }
++            else {
++                transaction->state = RM_ERROR_TRANSPORT_SEND_NOT_REGD;
++            }                
++        }
 +
-     return RM_OK;
++        transaction->hasBeenForwarded = true;
++        /* Transaction not deleted.  Waiting for response from RM CD or Server */
++    }
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function is called on slave DSPs after the master DSP has populated
-  *      the internal permission tables.  This function invalidates all internal
-  *      global permission tables so that no further invalidates are required
-  *      when LLDs perform resource permission checks
-  *
++/* FUNCTION PURPOSE: Issues an allocator operation
++ ***********************************************************************
++ * DESCRIPTION: Issues an allocator preallocate, allocate, or free
++ *              for an RM resource.
 + */
- void Rm_updatePermissionTables(void)
++static int32_t allocatorOperation(Rm_Inst *rmInst, Rm_AllocatorOpInfo *opInfo)
 +{
-     uint16_t dmaIndex;
-     const uint16_t dmaTxCh[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_TX_CH, 
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                                 RM_CPPI_AIF_TX_CH,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_A_TX_CH, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_B_TX_CH, 
- #endif                                          
- #ifdef QMSS_MAX_PASS_QUEUE
-                                                 RM_CPPI_PASS_TX_CH, 
- #endif                                                
-                                                 RM_CPPI_QMSS_TX_CH,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                                 RM_CPPI_FFTC_C_TX_CH,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                                 RM_CPPI_BCP_TX_CH
- #endif                                                                       
-                                                };
-     const uint16_t dmaRxCh[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_RX_CH, 
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                                 RM_CPPI_AIF_RX_CH,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_A_RX_CH, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_B_RX_CH, 
- #endif                                                       
- #ifdef QMSS_MAX_PASS_QUEUE
-                                                 RM_CPPI_PASS_RX_CH, 
- #endif                                                
-                                                 RM_CPPI_QMSS_RX_CH,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                                 RM_CPPI_FFTC_C_RX_CH,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                                 RM_CPPI_BCP_RX_CH
- #endif                                                                       
-                                                };
-     const uint16_t dmaFlow[RM_CPPI_MAX_DMAS] = {RM_CPPI_SRIO_FLOW, 
- #ifdef QMSS_MAX_AIF_QUEUE      
-                                                 RM_CPPI_AIF_FLOW,
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_A_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_A_FLOW, 
- #endif                                                                       
- #ifdef QMSS_MAX_FFTC_B_QUEUE                                                                       
-                                                 RM_CPPI_FFTC_B_FLOW, 
- #endif                                                                
- #ifdef QMSS_MAX_PASS_QUEUE
-                                                 RM_CPPI_PASS_FLOW, 
- #endif                                                
-                                                 RM_CPPI_QMSS_FLOW,
- #ifdef QMSS_MAX_FFTC_C_QUEUE
-                                                 RM_CPPI_FFTC_C_FLOW,
- #endif
- #ifdef QMSS_MAX_BCP_QUEUE
-                                                 RM_CPPI_BCP_FLOW
- #endif                                                                       
-                                                }; 
++    Rm_Allocator *allocator = NULL;
++    int32_t       resourceOffsetInPolicy;
++    int32_t       retVal;
 +    
-     /* Invalidate all permission tables so no further invalidates are required
-       * on slave cores */
-     /* Global permissions object */
-     Rm_osalBeginMemAccess ((void *) &rmGPermsObj, sizeof (Rm_GlobalPermissionsObj));
++    resourceOffsetInPolicy = rmPolicyGetResourceOffset(rmInst->policy, opInfo->resourceInfo->name);
++    allocator = rmAllocatorFind(rmInst->allocators, opInfo->resourceInfo->name);
 +    
-     /* QMSS Permission Tables */
-     /* QMSS PDSPs */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssPdspFirmwarePerms, sizeof (Rm_Perms) * RM_QMSS_FIRMWARE_PDSPS);
-     /* QMSS Queues */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssQueuePerms, sizeof (Rm_Perms) * RM_QMSS_QUEUES);
-     /* QMSS Memory Regions */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssMemRegionPerms, sizeof (Rm_Perms) * RM_QMSS_MEM_REGIONS);    
-     /* QMSS Linking RAM */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssLinkRamPerms, sizeof (Rm_qmssLinkingRamPerms) * RM_QMSS_LINKING_RAM_RANGES);
-     /* QMSS Accumulator Channels */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssAccumChPerms, sizeof (Rm_Perms) * RM_QMSS_ACCUM_CH);   
-     /* QMSS QOS Clusters */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssQosClusterPerms, sizeof (Rm_Perms) * RM_QMSS_QOS_CLUSTER);   
-     /* QMSS QOS Queues */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.qmssQosQueuePerms, sizeof (Rm_Perms) * RM_QMSS_QOS_QUEUES);       
-     /* CPPI Permission Tables */
-     
-     /* CPPI DMA Transmit Channels */
-     for (dmaIndex = 0; dmaIndex < RM_CPPI_MAX_DMAS; dmaIndex++)
-     {
-         Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[dmaIndex], sizeof (Rm_Perms)*dmaTxCh[dmaIndex]); 
++    if ((resourceOffsetInPolicy > 0) && allocator) {
++        if (opInfo->operation == Rm_allocatorOp_PRE_ALLOCATE) {
++            retVal = treePreAllocate(rmInst, allocator, resourceOffsetInPolicy, opInfo);
++        }               
++        else if (opInfo->operation == Rm_allocatorOp_ALLOCATE) {
++            retVal = treeAllocate(rmInst, allocator, resourceOffsetInPolicy, opInfo);
++        }
++        else if (opInfo->operation == Rm_allocatorOp_FREE) {
++            retVal = treeFree(allocator, opInfo);
++        }         
 +    }
-     /* CPPI DMA Receive Channels */
-     for (dmaIndex = 0; dmaIndex < RM_CPPI_MAX_DMAS; dmaIndex++)
-     {
-         Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[dmaIndex], sizeof (Rm_Perms)*dmaRxCh[dmaIndex]); 
++    else {
++        /* Resource could not be found in policy and/or allocator */
++        retVal = RM_SERVICE_DENIED_RES_DOES_NOT_EXIST;
 +    }
-     /* CPPI DMA Receive Flows */
-     for (dmaIndex = 0; dmaIndex < RM_CPPI_MAX_DMAS; dmaIndex++)
-     {
-         Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[dmaIndex], sizeof (Rm_Perms)*dmaFlow[dmaIndex]); 
++    return(retVal);
++}
++
++/* FUNCTION PURPOSE: Arbitrates allocation service requests
++ ***********************************************************************
++ * DESCRIPTION: Issues a set of allocator operations in order to
++ *              handle a received allocation request.  Allocation
++ *              requests are always forwarded to the Server on Client
++ *              CD instances.  If a request is made with a NameServer
++ *              name the resource base and length parameters are
++ *              retrieved from the NameServer prior to the allocation
++ *              attempt.
++ */
++static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *validInstNode,
++                               uint32_t allocType)
++{
++    Rm_AllocatorOpInfo  opInfo;
++    Rm_NameServerObjCfg nameServerObjCfg;
++    int32_t             retVal = transaction->state;
++
++    memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
++    
++    if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
++        /* Forward all allocation requests to Server if transport is up.  Otherwise, just queue. */
++        if (rmInst->registeredWithDelegateOrServer) {
++            transactionForwarder(rmInst, transaction);   
++        }  
 +    }
++    else if (rmInst->instType == Rm_instType_SERVER) {
++        opInfo.resourceInfo = &transaction->resourceInfo;
++        opInfo.serviceSrcInstNode = validInstNode;
++        opInfo.allocType = allocType;
++
++        /* Populated NameServer name has precedence over base */
++        if (strlen(transaction->resourceInfo.nameServerName) > 0) {
++            if ((transaction->resourceInfo.base == 0) &&
++                (transaction->resourceInfo.length == 0) &&
++                (transaction->resourceInfo.alignment == 0)) {
++                memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
++                nameServerObjCfg.nameServerTree = rmInst->nameServer;
++                nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
++                if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {
++                    strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
++                    transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
++                    transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
++                }                
++            }
++            else {
++                retVal = RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT;
++            }
++        }
 +
-     /* PA permission tables */
++        if (retVal == RM_SERVICE_PROCESSING) {      
++            if (transaction->resourceInfo.base == RM_RESOURCE_BASE_UNSPECIFIED) {
++                opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE;
++                retVal = allocatorOperation(rmInst, &opInfo);
++            }
++        
++            if (retVal == RM_SERVICE_PROCESSING) {
++                opInfo.operation = Rm_allocatorOp_ALLOCATE;
++                retVal = allocatorOperation(rmInst, &opInfo);
++            }      
++        }
++        
++        transaction->state = retVal;
 +
-     /* PA Firmware invalidated as part of global permissions object invalidate */
-     /* PA LUTs */
-     Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.paLutPerms, sizeof (Rm_Perms) * RM_PA_LUT);   
++        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++            /* Source of allocation was not the server instance, provide the transaction
++             * to the transaction responder */
++            transactionResponder(rmInst, transaction);
++        }
++        /* Otherwise let the return stack return the transaction to the serviceHandler */                   
++    }   
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function extracts the initialization permission for a DSP from a resource
-  *      permission element.
-  *
-  *  @param[in]  resourcePermissions
-  *      A permissions structure element to extract the per DSP initialization permission
-  *
-  *  @retval
-  *      Success -   RM_INIT_PERMISSION_APPROVED
-  *  @retval
-  *      Failure -   RM_INIT_PERMISSION_DENIED
++/* FUNCTION PURPOSE: Arbitrates free service requests
++ ***********************************************************************
++ * DESCRIPTION: Issues a set of allocator operations in order to
++ *              handle a received free request.  Free
++ *              requests are always forwarded to the Server on Client
++ *              CD instances.  If a request is made with a NameServer
++ *              name the resource base and length parameters are
++ *              retrieved from the NameServer prior to the free
++ *              attempt.
 + */
- Rm_Result Rm_getInitPermissions (Rm_Perms *resourcePermissions)
++static void freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *validInstNode)
 +{
-     /* Check the init permissions for the calling DSP */
-     if (!(RM_GET_PERMISSIONS(resourcePermissions->initPerms)))
-     {
-         return RM_INIT_PERMISSION_DENIED;
++    Rm_AllocatorOpInfo  opInfo; 
++    Rm_NameServerObjCfg nameServerObjCfg;    
++    int32_t             retVal = transaction->state;
++
++    memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
++    
++    if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
++        /* Forward all free requests to Server if transport is up.  Otherwise, just queue. */
++        if (rmInst->registeredWithDelegateOrServer) {
++            transactionForwarder(rmInst, transaction);   
++        }
 +    }
-   
-     return RM_INIT_PERMISSION_APPROVED;
++    else if (rmInst->instType == Rm_instType_SERVER) {
++        opInfo.resourceInfo = &transaction->resourceInfo;
++        opInfo.serviceSrcInstNode = validInstNode;
++
++        /* Populated NameServer name has precedence over base */
++        if (strlen(transaction->resourceInfo.nameServerName) > 0) {
++            if ((transaction->resourceInfo.base == 0) &&
++                (transaction->resourceInfo.length == 0) &&
++                (transaction->resourceInfo.alignment == 0)) {
++                memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
++                nameServerObjCfg.nameServerTree = rmInst->nameServer;
++                nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
++                if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {
++                    strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
++                    transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
++                    transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
++                } 
++            }
++            else {
++                retVal = RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT;
++            }                
++        }
++        
++        if(retVal == RM_SERVICE_PROCESSING) {        
++            opInfo.operation = Rm_allocatorOp_FREE;
++            retVal = allocatorOperation(rmInst, &opInfo);
++        }       
++
++        transaction->state = retVal;
++
++        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++            /* Source of allocation was not the server instance, provide the transaction
++             * to the transaction responder */
++            transactionResponder(rmInst, transaction);
++        }
++        /* Otherwise let the return stack return the transaction to the serviceHandler */        
++    }   
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function extracts the usage permission for a DSP from a resource
-  *      permission element.
-  *
-  *  @param[in]  resourcePermissions
-  *      A permissions structure element to extract the per DSP usage permission
-  *
-  *  @retval
-  *      Success -   RM_INIT_PERMISSION_APPROVED
-  *  @retval
-  *      Failure -   RM_INIT_PERMISSION_DENIED
++/* FUNCTION PURPOSE: Reserves a Linux resource
++ ***********************************************************************
++ * DESCRIPTION: Reserves resources for Linux using the base and length
++ *              values retrieved from the Linux DTB via the
++ *              "linux-dtb-alias" properties within the GRL.
 + */
- Rm_Result Rm_getUsePermissions (Rm_Perms *resourcePermissions)
++static int32_t reserveLinuxResource(Rm_Inst *rmInst, Rm_LinuxAlias *linuxAlias, 
++                                    Rm_LinuxValueRange *linuxValues, Rm_AllocatorOpInfo *opInfo)
 +{
-     /* Check the use permissions for the calling DSP */
-     if (!(RM_GET_PERMISSIONS(resourcePermissions->usePerms)))
-     {
-         return RM_USE_PERMISSION_DENIED;
++    int32_t  retVal = RM_OK;
++    bool     baseFound = false;
++    bool     lengthFound = false;
++    uint32_t valueIndex = 0;
++
++    while ((linuxValues) && (!baseFound || !lengthFound)) {
++        if (linuxAlias->baseOffset == valueIndex) {
++            opInfo->resourceInfo->base = linuxValues->value;
++            baseFound = true;
++
++            if (linuxAlias->lengthOffset == RM_DTB_UTIL_LINUX_ALIAS_OFFSET_NOT_SET) {
++                opInfo->resourceInfo->length = 1;
++                lengthFound = true;
++            }
++        }
++        else if (linuxAlias->lengthOffset == valueIndex) {
++            opInfo->resourceInfo->length = linuxValues->value;
++            lengthFound = true;
++        }
++
++        linuxValues = (Rm_LinuxValueRange *)linuxValues->nextValue;
++        valueIndex++;
++    }
++
++    if (!baseFound || !lengthFound) {
++        retVal = RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS;
++    }
++    else {
++        /* Allocate resource to Linux */
++        retVal = allocatorOperation(rmInst, opInfo);
 +    }
-   
-     return RM_USE_PERMISSION_APPROVED;
++    return (retVal);
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function searches the list of linking RAM address ranges to find one that has
-  *      the requested linking RAM address within it.  If found the function returns the permissions
-  *      for this range.  Otherwise it returns denied.
-  *
-  *  @param[in]  isInitCheck
-  *      True - Permissions check is for initialization
-  *      False - Permissions check is for usage
-  *
-  *  @param[in]  linkRamPermArray
-  *      Internal array of linking RAM ranges and their permissions
-  *
-  *  @param[in]  linkRamResData
-  *      Linking RAM addresses to check for initialization or usage permissions
-  *
-  *  @retval
-  *      Success -   RM_INIT_PERMISSION_APPROVED
-  *  @retval
-  *      Failure -   RM_INIT_PERMISSION_DENIED
++/* FUNCTION PURPOSE: Finds and reserves Linux resources
++ ***********************************************************************
++ * DESCRIPTION: Parses the Linux DTB for resources consumed by the
++ *              Linux kernel.  If the resource is found via the
++ *              "linux-dtb-alias" property defined in the GRL it is 
++ *              reserved.
 + */
- Rm_Result Rm_getLinkRamPermissions (Bool isInitCheck, Rm_qmssLinkingRamPerms *linkRamPermArray, Rm_ResourceInfo *linkRamResData)
++static int32_t findAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName, void *linuxDtb, 
++                                           Rm_LinuxAlias *linuxAlias)
 +{
-     Rm_Result retVal;
-     uint16_t linkRamIndex;
++    Rm_AllocatorOpInfo  opInfo;
++    Rm_ResourceInfo     resourceInfo;
++    uint32_t            pathOffset;
++    uint32_t            pathSize;
++    char               *spacePtr;
++    int32_t             propOffset;
++    int32_t             nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;
++    int32_t             prevDepth = RM_DTB_UTIL_STARTING_DEPTH;
++    int32_t             depth;
++    int32_t             propertyLen;
++    const char         *propertyName;
++    const void         *propertyData; 
++    Rm_LinuxValueRange *linuxValueRange;
++    int32_t             retVal = RM_OK; 
++
++    memset((void *) &opInfo, 0, sizeof(Rm_AllocatorOpInfo));
++    memset((void *) &resourceInfo, 0, sizeof(Rm_ResourceInfo));
++
++    strncpy(resourceInfo.name, resourceName, RM_NAME_MAX_CHARS);
++    opInfo.serviceSrcInstNode = rmPolicyGetLinuxInstNode(rmInst->validInstances);
++    opInfo.operation = Rm_allocatorOp_ALLOCATE;
++    opInfo.resourceInfo = &resourceInfo;    
++
++    while(linuxAlias) {
++        /* Reset parsing variables */
++        pathOffset = 0;
++        pathSize = strlen(linuxAlias->path) + 1;
++        nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;
++        prevDepth = RM_DTB_UTIL_STARTING_DEPTH;   
++        resourceInfo.base = 0;
++        resourceInfo.length = 0;
++
++        spacePtr = strpbrk(linuxAlias->path, " ");
++        if (spacePtr) {
++            *spacePtr = '\0';
++        }       
++        
++        while(pathOffset < pathSize) {
++            /* Move through DTB nodes until next alias path node found */
++            if (strcmp(linuxAlias->path + pathOffset, fdt_get_name(linuxDtb, nodeOffset, NULL))) {
++                nodeOffset = fdt_next_node(linuxDtb, nodeOffset, &depth);
++
++                if ((depth < prevDepth) || (nodeOffset == -FDT_ERR_NOTFOUND)) {
++                    /* Returning from subnode that matched part of alias path without finding
++                     * resource values */
++                    retVal = RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS;
++                    break;
++                }
++            }
++            else {
++                /* Found next alias path node.  Move to next node name in path string. */
++                pathOffset += (strlen(linuxAlias->path + pathOffset) + 1);
++                spacePtr = strpbrk(linuxAlias->path + pathOffset, " ");
++                if (spacePtr) {
++                    *spacePtr = '\0';
++                }       
++                
++                prevDepth = fdt_node_depth(linuxDtb, nodeOffset);
++              propOffset = fdt_first_property_offset(linuxDtb, nodeOffset);
++                while ((propOffset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) &&
++                       (pathOffset < pathSize)) {
++                    propertyData = fdt_getprop_by_offset(linuxDtb, propOffset, 
++                                                         &propertyName, &propertyLen);
++
++                    if (strcmp(linuxAlias->path + pathOffset, propertyName) == 0) {
++                        /* Found resource at end of alias path */
++                        pathOffset += (strlen(linuxAlias->path + pathOffset) + 1);
++                        linuxValueRange = rmDtbUtilLinuxExtractValues(propertyData, propertyLen);
++                        retVal = reserveLinuxResource(rmInst, linuxAlias, 
++                                                      linuxValueRange, &opInfo);
++                        rmDtbUtilLinuxFreeValues(linuxValueRange);
++                    }
++                    propOffset = fdt_next_property_offset(linuxDtb, propOffset);
++                } 
 +
-     /* Initialize the return value based on type of check boolean */
-     if (isInitCheck)
-     {
-         retVal = RM_INIT_PERMISSION_DENIED;
-     }
-     else
-     {
-         retVal = RM_USE_PERMISSION_DENIED;
++                if (propOffset < -FDT_ERR_NOTFOUND) {
++                    retVal = propOffset;
++                    break;
++                }
++            }
++        }
++
++        if (retVal < RM_OK) {
++            break;
++        }
++        linuxAlias = linuxAlias->nextLinuxAlias;
 +    }
-     
-     for (linkRamIndex = 0; linkRamIndex < RM_QMSS_LINKING_RAM_RANGES; linkRamIndex++)
-     {
-         if ((linkRamResData->res_info.linkRamData.linkRamStartIndex >= linkRamPermArray[linkRamIndex].startIndex) &&
-              (linkRamResData->res_info.linkRamData.linkRamEndIndex <= linkRamPermArray[linkRamIndex].endIndex))
-         {
-             /* Check the use permissions for the calling DSP */
-             if (isInitCheck)
-             {
-                 if (RM_GET_PERMISSIONS(linkRamPermArray[linkRamIndex].rangePerms.initPerms))
-                 {
-                     retVal = RM_USE_PERMISSION_APPROVED;
++    return (retVal);
++}
++
++/* FUNCTION PURPOSE: Creates and initializes a resource allocator
++ ***********************************************************************
++ * DESCRIPTION: Creates a resource allocator for the provided
++ *              resource name and resource properties retrieved
++ *              from the GRL.  Resources will be reserved for 
++ *              the Linux kernel if the Linux DTB is provided
++ *              and there are "linux-dtb-alias" properties
++ *              specified in the GRL.
++ */
++static int32_t createAndInitAllocator(Rm_Inst *rmInst, const char *resourceName, 
++                                      Rm_ResourceProperties *resourceProperties, void *linuxDtb)
++{
++    Rm_ResourceRange    *range = NULL;
++    Rm_ResourceRange    *rangeBasePtr = NULL;
++    Rm_NsAssignment     *nsAssignments = NULL;
++    Rm_NsAssignment     *nsAssignmentBasePtr = NULL;
++    Rm_LinuxAlias       *linuxAlias = NULL;
++    Rm_NameServerObjCfg  nameServerObjCfg;      
++    int32_t              retVal = RM_OK;
++
++    if (resourceProperties->rangeData && (resourceProperties->rangeLen > 0)) {
++        range = rangeBasePtr = rmDtbUtilResExtractRange(resourceProperties->rangeData, 
++                                                        resourceProperties->rangeLen);
++        
++        if ((retVal = createResourceTree(rmInst, resourceName, range)) >= RM_OK) {
++            if (resourceProperties->linuxAliasData && resourceProperties->linuxAliasLen) {
++                if (linuxDtb) {
++                    linuxAlias = rmDtbUtilResExtractLinuxAlias(resourceProperties->linuxAliasData,
++                                                               resourceProperties->linuxAliasLen, &retVal);
++                    if (linuxAlias) {
++                        retVal = findAndReserveLinuxResource(rmInst, resourceName, linuxDtb, linuxAlias);            
++                    }
++                }
++                else {
++                    retVal = RM_ERROR_GRL_LINUX_ALIAS_BUT_NO_DTB;
 +                }
 +            }
-             else
-             {
-                 if (RM_GET_PERMISSIONS(linkRamPermArray[linkRamIndex].rangePerms.usePerms))
-                 {
-                     retVal = RM_USE_PERMISSION_APPROVED;
++        }
++    }
++    
++    if (retVal >= RM_OK) {
++        if (resourceProperties->nsAssignData && resourceProperties->nsAssignLen) {
++            nsAssignments = rmDtbUtilResExtractNsAssignment(resourceProperties->nsAssignData, 
++                                                            resourceProperties->nsAssignLen, &retVal);
++            if (nsAssignments) {
++                nsAssignmentBasePtr = nsAssignments;
++                while (nsAssignments) {
++                    memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
++                    nameServerObjCfg.nameServerTree = rmInst->nameServer;
++                    nameServerObjCfg.nodeCfg.objName = nsAssignments->nsName;
++                    nameServerObjCfg.nodeCfg.resourceName = (char *)resourceName;
++                    nameServerObjCfg.nodeCfg.resourceBase= nsAssignments->resourceBase;
++                    nameServerObjCfg.nodeCfg.resourceLength = nsAssignments->resourceLength;                
++                    rmNameServerAddObject(&nameServerObjCfg);
++                    nsAssignments = nsAssignments->nextNsAssignment;
 +                }
++                rmDtbUtilResFreeNsAssignmentList(nsAssignmentBasePtr);
 +            }
-             break;
 +        }
 +    }
 +
++    rmDtbUtilResFreeRange(rangeBasePtr);
++    if (linuxAlias) {
++        rmDtbUtilResFreeLinuxAlias(linuxAlias);
++    }
++    return(retVal);
++}
++
++/* FUNCTION PURPOSE: Recursively parses GRL resource properties
++ ***********************************************************************
++ * DESCRIPTION: Recursively parses and stores GRL resource node 
++ *              properties using the LIBFDT APIs
++ */
++static int32_t parseResourceProperty(void *globalResourceDtb, int32_t offset, 
++                                     Rm_ResourceProperties *propertyInfo)
++{
++      int32_t              propertyLen;
++      const char          *propertyName;
++      const void          *propertyData;
++    Rm_ResourcePropType  propertyType;
++    int32_t              retVal = RM_OK;
++
++      propertyData = fdt_getprop_by_offset(globalResourceDtb, offset, &propertyName, &propertyLen);
++    propertyType = rmDtbUtilResGetPropertyType(propertyName);
++    if (propertyType == Rm_resourcePropType_RESOURCE_RANGE) {
++        propertyInfo->rangeData = propertyData;
++        propertyInfo->rangeLen = propertyLen;
++    }
++    else if (propertyType == Rm_resourcePropType_NSASSIGNMENT) {
++        propertyInfo->nsAssignData = propertyData;
++        propertyInfo->nsAssignLen = propertyLen;
++    }
++    else if (propertyType == Rm_resourcePropType_RESOURCE_LINUX_ALIAS) {
++        propertyInfo->linuxAliasData = propertyData;
++        propertyInfo->linuxAliasLen = propertyLen;
++    }        
++    else {
++        retVal = RM_ERROR_GRL_UNKNOWN_RESOURCE_PROPERTY;
++    }
++
++    if (retVal == RM_OK) {
++        offset = fdt_next_property_offset(globalResourceDtb, offset);
++      if (offset >= 0) {
++          retVal = parseResourceProperty(globalResourceDtb, offset, propertyInfo);
++      }
++        else if (offset != -FDT_ERR_NOTFOUND) {
++            /* Error returned by LIBFDT */
++            retVal = offset;
++        }
++    }
 +    return (retVal);
 +}
 +
- /**********************************************************************
-  **********APIs visible to other LLDs internally via call table *******************
-  **********************************************************************/
++/* FUNCTION PURPOSE: Recursively parses GRL resource nodes
++ ***********************************************************************
++ * DESCRIPTION: Recursively parses GRL resource nodes looking for
++ *              resource properties to create the resource allocators.
++ *              The LIBFDT APIs are used to parse the GRL.
++ */
++static int32_t parseResourceNode(Rm_Inst *rmInst, void *globalResourceDtb, int32_t nodeOffset, int32_t depth,
++                                 void *linuxDtb)
++{
++      const char            *resourceName = fdt_get_name(globalResourceDtb, nodeOffset, NULL);
++    Rm_ResourceProperties  resourceProperties;
++      int32_t                retVal = RM_OK;
++      int32_t                offset;
++
++    memset((void *)&resourceProperties, 0, sizeof(Rm_ResourceProperties));
++    /* Get properties of resource node */
++      offset = fdt_first_property_offset(globalResourceDtb, nodeOffset);
++      if (offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) {
++              retVal =  parseResourceProperty(globalResourceDtb, offset, &resourceProperties);
++        if (retVal < -FDT_ERR_NOTFOUND) {
++            return (retVal);
++        }
++        if (retVal = createAndInitAllocator(rmInst, resourceName, &resourceProperties, linuxDtb) < RM_OK) {
++            return (retVal);
++        }
++      }
++    else if (offset != -FDT_ERR_NOTFOUND) {
++              /* Error returned by LIBFDT */
++        return (offset);
++    }
++    
++      offset = fdt_next_node(globalResourceDtb, nodeOffset, &depth);
++    if ((offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) && (depth >= RM_DTB_UTIL_STARTING_DEPTH)) {
++        retVal = parseResourceNode(rmInst, globalResourceDtb, offset, depth, linuxDtb);
++        if (retVal < -FDT_ERR_NOTFOUND) {
++            return (retVal);
++        }
++    }
++    else if (offset != -FDT_ERR_NOTFOUND) {
++        /* Error returned by LIBFDT */
++        return (offset);
++    }
++    return (retVal);
++}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function is used by LLDs to check initialization permissions for a resource
-  *
-  *  @param[in]  resourceData
-  *      Structure containing resource information such as resource type and the
-  *      resource value to be checked
-  *
-  *  @retval
-  *      Success -   RM_INIT_PERMISSION_APPROVED
-  *  @retval
-  *      Failure -   RM_INIT_PERMISSION_DENIED
++/* FUNCTION PURPOSE: Initializes server allocators
++ ***********************************************************************
++ * DESCRIPTION: Creates and initializes a server instance's
++ *              resource allocators using the GRL and, if
++ *              provided, Linux DTB.
 + */
- Rm_Result Rm_initPermissionChecker (Rm_ResourceInfo *resourceData)
++static int32_t initializeAllocators(Rm_Inst *rmInst, void *globalResourceDtb, void *linuxDtb)
 +{
-     switch (resourceData->resourceType)
-     {
-         case Rm_resource_QMSS_FIRMWARE_PDSP:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssPdspFirmwarePerms[resourceData->res_info.pdspNum]));
-             
-         case Rm_resource_QMSS_QUEUE:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQueuePerms[resourceData->res_info.queNum]));
-             
-         case Rm_resource_QMSS_MEMORY_REGION:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssMemRegionPerms[resourceData->res_info.memRegion]));
++    int32_t nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;
++    int32_t startDepth = RM_DTB_UTIL_STARTING_DEPTH;
++    int32_t result = RM_OK;
 +
-         case Rm_resource_QMSS_LINKING_RAM_CONTROL:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssLinkRamControlPerms));   
-             
-         case Rm_resource_QMSS_LINKING_RAM:
-             return (Rm_getLinkRamPermissions (TRUE, &rmGPermsObj.obj.qmssLinkRamPerms[0], resourceData));
-             
-         case Rm_resource_QMSS_ACCUM_CH:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssAccumChPerms[resourceData->res_info.accumCh]));  
++    /* Recursively parse the Global Resource List, creating an allocator for
++     * each resource as specified in the node */
++    result = parseResourceNode(rmInst, globalResourceDtb, nodeOffset, startDepth, linuxDtb);
 +
-         case Rm_resource_QMSS_QOS_TIMER:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQosPdspTimerPerms));   
++    return(result);
++}
 +
-         case Rm_resource_QMSS_QOS_CLUSTER:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQosClusterPerms[resourceData->res_info.qosCluster]));           
++/**********************************************************************
++ ********************** Internal Functions ****************************
++ **********************************************************************/
 +
-         case Rm_resource_QMSS_QOS_QUEUE:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQosQueuePerms[resourceData->res_info.qosQueue]));                
-             
-         case Rm_resource_CPPI_TX_CH:
-             {
-                 Rm_Perms *txChPermsArray = rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getInitPermissions(&txChPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));
-             }
-             
-         case Rm_resource_CPPI_RX_CH:
-             {
-                 Rm_Perms *rxChPermsArray = rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getInitPermissions(&rxChPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));
-             }
-             
-         case Rm_resource_CPPI_RX_FLOW:
-             {
-                 Rm_Perms *flowPermsArray = rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getInitPermissions(&flowPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));       
++/* FUNCTION PURPOSE: Adds a transaction
++ ***********************************************************************
++ * DESCRIPTION: Returns a pointer to a newly created transaction.
++ *              The transaction is created based on a new service
++ *              request received via the service API or the
++ *              transport API (service forwarded from another instance)
++ */
++Rm_Transaction *rmTransactionQueueAdd(Rm_Inst *rmInst)
++{
++    Rm_Transaction *transactionQueue = rmInst->transactionQueue;
++    Rm_Transaction *newTransaction   = NULL;
++
++    newTransaction = Rm_osalMalloc(sizeof(Rm_Transaction));
++    if (newTransaction) {
++        memset((void *)newTransaction, 0, sizeof(Rm_Transaction));
++
++        newTransaction->localId = transactionGetSequenceNum(rmInst);
++        newTransaction->nextTransaction = NULL;  
++        if (transactionQueue) {
++            while (transactionQueue->nextTransaction) {
++                transactionQueue = transactionQueue->nextTransaction;
 +            }
-             
-         case Rm_resource_PA_FIRMWARE:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.paFirmwarePerms));    
-             
-         case Rm_resource_PA_LUT:
-             return (Rm_getInitPermissions(&rmGPermsObj.obj.paLutPerms[resourceData->res_info.lutEntry]));   
-      
-         default:
-             return (RM_INIT_PERMISSION_DENIED);
++            transactionQueue->nextTransaction = newTransaction;
++        }
++        else {
++            rmInst->transactionQueue = newTransaction;
++        }
 +    }
++    return (newTransaction);
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function is used by LLDs to check usage permissions for a resource
-  *
-  *  @param[in]  resourceData
-  *      Structure containing resource information such as resource type and the
-  *      resource value to be checked
-  *
-  *  @retval
-  *      Success -   RM_INIT_PERMISSION_APPROVED
-  *  @retval
-  *      Failure -   RM_INIT_PERMISSION_DENIED
++/* FUNCTION PURPOSE: Finds a transaction
++ ***********************************************************************
++ * DESCRIPTION: Returns a pointer to a transaction resident
++ *              in the transaction queue that matches the provided
++ *              transaction ID.
 + */
- Rm_Result Rm_usePermissionChecker (Rm_ResourceInfo *resourceData)
++Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId)
 +{
-     switch (resourceData->resourceType)
-     {
-         case Rm_resource_QMSS_FIRMWARE_PDSP:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssPdspFirmwarePerms[resourceData->res_info.pdspNum]));
-             
-         case Rm_resource_QMSS_QUEUE:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQueuePerms[resourceData->res_info.queNum]));
-             
-         case Rm_resource_QMSS_MEMORY_REGION:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssMemRegionPerms[resourceData->res_info.memRegion]));
++    Rm_Transaction *transaction = rmInst->transactionQueue;
 +
-         case Rm_resource_QMSS_LINKING_RAM_CONTROL:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssLinkRamControlPerms));   
-             
-         case Rm_resource_QMSS_LINKING_RAM:
-             return (Rm_getLinkRamPermissions(FALSE, &rmGPermsObj.obj.qmssLinkRamPerms[0], resourceData));
-             
-         case Rm_resource_QMSS_ACCUM_CH:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssAccumChPerms[resourceData->res_info.accumCh]));     
++    while (transaction) {
++        if (transaction->localId == transactionId) {
++            break;             
++        }
++        transaction = transaction->nextTransaction;
++    }
 +
-         case Rm_resource_QMSS_QOS_TIMER:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQosPdspTimerPerms));   
++    return (transaction);
++}
 +
-         case Rm_resource_QMSS_QOS_CLUSTER:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQosClusterPerms[resourceData->res_info.qosCluster]));           
++/* FUNCTION PURPOSE: Deletes a transaction
++ ***********************************************************************
++ * DESCRIPTION: Deletes the transaction with the provided transaction
++ *              ID from the instance's transaction queue.
++ */
++int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
++{
++    Rm_Transaction *transaction     = rmInst->transactionQueue;
++    Rm_Transaction *prevTransaction = NULL;
++    int32_t         retVal          = RM_OK;
 +
-         case Rm_resource_QMSS_QOS_QUEUE:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQosQueuePerms[resourceData->res_info.qosQueue]));                
-             
-         case Rm_resource_CPPI_TX_CH:
-             {
-                 Rm_Perms *txChPermsArray = rmGPermsObj.obj.cppiTxChPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getUsePermissions(&txChPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));
-             }
-             
-         case Rm_resource_CPPI_RX_CH:
-             {
-                 Rm_Perms *rxChPermsArray = rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getUsePermissions(&rxChPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));
++    while (transaction) {
++        if (transaction->localId == transactionId) {
++            break;             
++        }
++
++        prevTransaction = transaction;
++        transaction = transaction->nextTransaction;
++    }
++
++    if (transaction) {
++        if (prevTransaction == NULL) {
++            /* Transaction at start of queue. Map second transaction to start of queue 
++             * as long as more than one transactions. */
++            rmInst->transactionQueue = transaction->nextTransaction;
++        }
++        else {
++            /* Transaction in middle or end of queue. */
++            prevTransaction->nextTransaction = transaction->nextTransaction;
++        }
++        Rm_osalFree((void *)transaction, sizeof(Rm_Transaction));
++    }
++    else {
++        retVal = RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST;
++    }    
++    return (retVal);
++}
++
++/* FUNCTION PURPOSE: Finds an allocator
++ ***********************************************************************
++ * DESCRIPTION: Returns a pointer to an allocator that matches the 
++ *              provided resource name.
++ */
++Rm_Allocator *rmAllocatorFind(Rm_Allocator *allocatorList, char *resourceName)
++{
++    while (allocatorList) {
++        if (strncmp(allocatorList->resourceName, resourceName, RM_NAME_MAX_CHARS) == 0) {
++            break;             
++        }
++        allocatorList = allocatorList->nextAllocator;
++    }
++
++    return (allocatorList);
++}
++
++/* FUNCTION PURPOSE: Processes a transaction
++ ***********************************************************************
++ * DESCRIPTION: Processes transactions created from services
++ *              received via the service handle or the transport.
++ *              Transactions will be routed within the RM system
++ *              based on the RM instance type and the type of
++ *              the transaction.
++ */
++void rmTransactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)
++{
++    void                *validInstNode;
++    Rm_PolicyCheckCfg    privCheckCfg;
++    Rm_NameServerObjCfg  nameServerObjCfg;      
++    uint32_t             allocType = 0;    
++
++    /* Handle static transactions originating on this instance.  Any other static transactions will be
++     * stored in transaction queue until all transports are up. */
++    if (((rmInst->instType == Rm_instType_CLIENT) || (rmInst->instType == Rm_instType_CLIENT_DELEGATE)) &&
++        (!rmInst->registeredWithDelegateOrServer) && 
++        (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS) == 0)) {
++        if (rmInst->staticInfo.staticPolicy) {
++            if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
++                (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE)) {
++                /* Check request against startup policy */
++                memset((void *)&privCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
++
++                if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
++                    privCheckCfg.type = Rm_policyCheck_INIT;
++                }
++                else {
++                    privCheckCfg.type = Rm_policyCheck_USE;
++                }
++                privCheckCfg.policyDtb = rmInst->staticInfo.staticPolicy;
++                privCheckCfg.validInstNode = rmPolicyGetValidInstNode(rmInst->staticInfo.staticValidInstTree, 
++                                                                      rmInst->instName);
++                privCheckCfg.resourceOffset = rmPolicyGetResourceOffset(rmInst->staticInfo.staticPolicy,
++                                                                        transaction->resourceInfo.name);
++                privCheckCfg.resourceBase = transaction->resourceInfo.base;
++                privCheckCfg.resourceLength = transaction->resourceInfo.length;
++
++                if (rmPolicyCheckPrivilege(&privCheckCfg, &transaction->state)) {
++                    transaction->state = RM_SERVICE_APPROVED_STATIC;
++                }
++                else if (transaction->state == RM_SERVICE_PROCESSING) {
++                    /* Privilege check returned false without error */
++                    transaction->state = RM_SERVICE_DENIED_BY_STATIC_POLICY;
++                }
 +            }
-             
-         case Rm_resource_CPPI_RX_FLOW:
-             {
-                 Rm_Perms *flowPermsArray = rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[resourceData->res_info.cpDmaData.dmaNum];
-                 return (Rm_getUsePermissions(&flowPermsArray[resourceData->res_info.cpDmaData.cppiChNumOrFlowId]));       
++            else {
++                transaction->state = RM_SERVICE_DENIED_INVALID_STATIC_REQUEST;
 +            }
-             
-         case Rm_resource_PA_FIRMWARE:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.paFirmwarePerms));    
-             
-         case Rm_resource_PA_LUT:
-             return (Rm_getUsePermissions(&rmGPermsObj.obj.paLutPerms[resourceData->res_info.lutEntry]));  
-      
-         default:
-             return (RM_USE_PERMISSION_DENIED);
++        }
++        else {
++            transaction->state = RM_ERROR_REQ_FAILED_NO_STATIC_POLICY;
++        }        
 +    }
- }
++    else {
++        /* Handle auto-forwarded transactions.  These transactions include:
++         * - All request transactions received on Clients are forwarded to the Client Delegate
++         * - NameServer requests received on the Client Delegate are forwarded to the Server */
++        if ((rmInst->instType == Rm_instType_CLIENT) ||
++            ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&
++             ((transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) ||
++              (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) ||
++              (transaction->type == Rm_service_RESOURCE_UNMAP_NAME)))) {
++              
++            if ((transaction->state != RM_SERVICE_PROCESSING) &&
++                (transaction->state != RM_SERVICE_APPROVED_STATIC)) {
++                if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++                    /* Transaction did not originate on this instance */
++                    transactionResponder(rmInst, transaction);
++                }
++                else {
++                    /* Transaction originated on this instance */
++                    serviceResponder(rmInst, transaction);
++                }
++            }
++            else {
++                /* Forward request if transport is up.  Otherwise, just queue. */
++                if (rmInst->registeredWithDelegateOrServer) {
++                    transactionForwarder(rmInst, transaction);   
++                } 
++            }
++        }
++        else {
++            /* Validate service's originating instance name */
++            if (rmInst->instType == Rm_instType_SERVER) {
++                validInstNode = rmPolicyGetValidInstNode(rmInst->validInstances, transaction->serviceSrcInstName);
++                if (validInstNode == NULL) {
++                    transaction->state = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;
++
++                    /* Send result via responder if transaction did not originate from this instance */
++                    if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++                        transactionResponder(rmInst, transaction);
++                    }
++                }
++            }
++
++            switch (transaction->type) {
++                case Rm_service_RESOURCE_ALLOCATE_INIT:
++                case Rm_service_RESOURCE_ALLOCATE_USE:
++                case Rm_service_RESOURCE_FREE:               
++                    if ((transaction->state != RM_SERVICE_PROCESSING) &&
++                        (transaction->state != RM_SERVICE_APPROVED_STATIC)) {
++                        /* Transaction complete */
++                        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++                            /* Transaction result not destined for this instance */
++                            transactionResponder(rmInst, transaction);
++                        }
++                        else {
++                            /* Transaction result destined for this instance */
++                            serviceResponder(rmInst, transaction);      
++                        }
++                    }
++                    else {
++                        /* Complete allocation/free request */
++                        if (transaction->type == Rm_service_RESOURCE_FREE) {
++                            freeHandler(rmInst, transaction, validInstNode);
++                        }
++                        else {
++                            switch (transaction->type) {
++                                case Rm_service_RESOURCE_ALLOCATE_INIT:
++                                    RM_policy_SET_PERM(allocType, RM_POLICY_PERM_INIT_SHIFT, 1);
++                                    break;
++                                case Rm_service_RESOURCE_ALLOCATE_USE:
++                                    RM_policy_SET_PERM(allocType, RM_POLICY_PERM_USE_SHIFT, 1);    
++                                    break;
++                            }
++                            allocationHandler(rmInst, transaction, validInstNode, allocType);
++                        }
++                    }
++                    break;
++                case Rm_service_RESOURCE_MAP_TO_NAME:
++                case Rm_service_RESOURCE_GET_BY_NAME:
++                case Rm_service_RESOURCE_UNMAP_NAME:                
++                    /* NameServer resides on server */
++                    memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
++                    if (rmInst->nameServer) {
++                        nameServerObjCfg.nameServerTree = rmInst->nameServer;
++                        nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
++                        if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) {
++                            nameServerObjCfg.nodeCfg.resourceName = transaction->resourceInfo.name;
++                            nameServerObjCfg.nodeCfg.resourceBase= transaction->resourceInfo.base;
++                            nameServerObjCfg.nodeCfg.resourceLength = transaction->resourceInfo.length;
++                            transaction->state = rmNameServerAddObject(&nameServerObjCfg);
++                        }
++                        else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {
++                            if ((transaction->state = rmNameServerFindObject(&nameServerObjCfg)) ==
++                                RM_SERVICE_PROCESSING) {
++                                strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
++                                transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
++                                transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
++                                transaction->state = RM_SERVICE_APPROVED;
++                            } 
++                        }
++                        else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {
++                            transaction->state = rmNameServerDeleteObject(&nameServerObjCfg);
++                        }
++                    }
++                    else {
++                        transaction->state = RM_ERROR_NAMESERVER_DOES_NOT_EXIST;
++                    }
 +
- /*  */
++                    /* Send result via responder if transaction did not originate from this instance */
++                    if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
++                        transactionResponder(rmInst, transaction);
++                    }
++                    break;
++            }
++        }
++    }
 +
++    /* Forward any queued requests that weren't forwarded yet */
++    if (rmInst->registeredWithDelegateOrServer) {
++        transaction = rmInst->transactionQueue;
++        while(transaction) {
++            if (((transaction->state == RM_SERVICE_PROCESSING) ||
++                 (transaction->state == RM_SERVICE_APPROVED_STATIC)) &&
++                !transaction->hasBeenForwarded) {
++                transactionForwarder(rmInst, transaction);
++            }
++            transaction = transaction->nextTransaction;
++        }
++    }
++}
++     
 +/**********************************************************************
-  *********************** Application visible APIs ***************************
++ ********************** Application visible APIs **********************
 + **********************************************************************/
 +
- /** @addtogroup RM_LLD_FUNCTION
- @{ 
- */
- /**
-  *  @b Description
-  *  @n  
-  *      This function initializes the Resource Manager low level driver
-  *      This function is called once in the system to setup the Resource Manager 
-  *      low level driver by mapping the application defined resource table to internal
-  *      permission tables.  After mapping is complete a global synchronization object
-  *      is written to sync with slave cores
-  *
-  *  @param[in]  rmResourceTable
-  *      Resource table defined by application.  Used to populate internal permission
-  *      tables.
-  *
-  *  @post  
-  *      RM LLD global permissions are set.
-  *
-  *  @retval
-  *      Success -   RM_OK
-  *  @retval
-  *      Failure -   RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED
++/* FUNCTION PURPOSE: Display status of managed resources
++ ***********************************************************************
++ * DESCRIPTION: Prints the status (allocate/free status, as well as
++ *              owners) for all resources managed by the RM 
++ *              instance network.  Also, prints the NameServer name
++ *              entries.  This function is only available on server
++ *              instances.
 + */
- Rm_Result Rm_init (const Rm_Resource *rmResourceTable)
++void Rm_printResourceStatus(Rm_Handle rmServerHandle)
 +{
-     void *key;
-     Rm_Result ret_val = RM_ERROR;
-     /* Check permission structure sizes to make sure they're evenly
-       * divisible into a cache line.  This generates no object code when
-       * optimizer is on.  If failes, assert will occur at compile time */
-     RM_COMPILE_TIME_SIZE_CHECK((RM_MAX_CACHE_ALIGN/sizeof(Rm_Perms)) * sizeof(Rm_Perms) == RM_MAX_CACHE_ALIGN);
-     RM_COMPILE_TIME_SIZE_CHECK((RM_MAX_CACHE_ALIGN/sizeof(Rm_qmssLinkingRamPerms)) * \
-                                                           sizeof(Rm_qmssLinkingRamPerms) == RM_MAX_CACHE_ALIGN);
-     /* Begin Critical Section before accessing shared resources. */
-     key = Rm_osalCsEnter ();
-     
-     /* Initialize the permissions table */
-     Rm_permissionTableInit();
++    Rm_Inst         *rmInst = (Rm_Inst *)rmServerHandle;
++    Rm_Allocator    *allocator = rmInst->allocators;
++    Rm_Owner        *owners;
++    Rm_ResourceTree *treeRoot;
++    Rm_ResourceNode *treeNode;
 +
-     if (!rmResourceTable)
-     {
-         /* End Critical Section */
-         Rm_osalCsExit (key);
-         return RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED;
-     }
++    if (rmInst->instType == Rm_instType_SERVER) {
++        while (allocator != NULL) {
++            Rm_osalLog("Resource: %s\n", allocator->resourceName);
 +
-     ret_val = Rm_populatePermissionTable(rmResourceTable);
++            treeRoot = allocator->allocatorRootEntry;
 +
-     /* End Critical Section */
-     Rm_osalCsExit (key);
-     return ret_val;
++            RB_FOREACH(treeNode, _Rm_AllocatorResourceTree, treeRoot) {               
++                Rm_osalLog("          %10d - %10d ", treeNode->base, 
++                                                     treeNode->base + treeNode->length -1);
++                
++                if (treeNode->allocationCount == 0) {
++                    Rm_osalLog("NOT ALLOCATED\n");
++                }
++                else {
++                    owners = treeNode->ownerList;
++                    Rm_osalLog("allocated to");
++                    while (owners) {
++                        Rm_osalLog(" %s", owners->instNameNode->name);
++                        owners = owners->nextOwner;
++                    }
++                    Rm_osalLog("\n");
++                }
++            }        
++            allocator = allocator->nextAllocator;
++        }
++        rmNameServerPrintObjects(rmInst->nameServer);
++    }
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function waits for the Resource Manager master to populate the 
-  *      global permissions table based on a global sync object.  Once the
-  *      global sync object has been written by the master core this function
-  *      will invalidate all permissions tables.  Since the permissions table are
-  *      static, and will not change through the system up-time, a single
-  *      invalidation at the start will suffice.
-  *      
-  *      This function can be called on all core besides that which called
-  *      Rm_init.  Calling this function on said cores will act as a blocking
-  *      synchronization point.
-  *
-  *  @retval
-  *      Success -   RM_OK
-  *  @retval
-  *      Failure -   RM_FAILURE
++/* FUNCTION PURPOSE: Display status of a RM instance
++ ***********************************************************************
++ * DESCRIPTION: Prints the current status of various RM instance
++ *              properties such as the state of all transactions
++ *              in the transaction queue and registered transports
 + */
- Rm_Result Rm_start (void)
++void Rm_printInstanceStatus(Rm_Handle rmHandle)
 +{
-     /* Loop until the global sync object signals the permissions table has been
-       * populated and valid */
-     do
-     {
-         /* Invalidate the global sync object */
-         Rm_osalBeginMemAccess ((void *) &rmGSyncObj, sizeof (Rm_Sync_Obj));
-     } while (rmGSyncObj.obj.globalSyncObj != RM_PERMISSION_TABLE_VALID);
++    Rm_Inst        *rmInst = (Rm_Inst *)rmHandle;
++    Rm_Transport   *transportList = (Rm_Transport *)rmInst->transports;
++    Rm_Transaction *transactionQ = rmInst->transactionQueue;
 +
-     /* Master core finished populating the permission tables.  Must invalidate
-       * all tables to see latest permissions */
-     Rm_updatePermissionTables();
++    Rm_osalLog("Instance name: %s\n", rmInst->instName);
++    if (rmInst->instType == Rm_instType_SERVER) {
++        Rm_osalLog("Type: Server\n");
++    }
++    else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
++        Rm_osalLog("Type: Client Delegate\n");
++    }
++    else {
++        Rm_osalLog("Type: Client\n");
++    }
++
++    if (transportList) {
++        Rm_osalLog("\nRegistered Transports:\n");
++        while (transportList) {
++            Rm_osalLog("    Remote instName:    %s\n", transportList->remoteInstName);
++            if (transportList->remoteInstType == Rm_instType_SERVER) {
++                Rm_osalLog("    Remote instType:    Server\n");
++            }
++            else if (transportList->remoteInstType == Rm_instType_CLIENT_DELEGATE) {
++                Rm_osalLog("    Remote instType:    Client Delegate\n");
++            }
++            else {
++                Rm_osalLog("    Remote instType:    Client\n");
++            }
++            Rm_osalLog("    appTransportHandle: 0x%08x\n", transportList->appTransportHandle);
++            Rm_osalLog("\n");
++            transportList = transportList->nextTransport;
++        }
++    }
 +
-     return RM_OK;
++    if (transactionQ) {
++        Rm_osalLog("\nQueued Service Transactions:\n");
++        while (transactionQ) {
++            Rm_osalLog("    Service type:       %d\n", transactionQ->type);
++            Rm_osalLog("    Service ID:         %d\n", transactionQ->localId);
++            Rm_osalLog("    Service srcInstName %s\n", transactionQ->serviceSrcInstName);
++            Rm_osalLog("    Service state:      %d\n", transactionQ->state);
++            Rm_osalLog("    Resource name:      %s\n", transactionQ->resourceInfo.name);
++            Rm_osalLog("    Resource base:      %d\n", transactionQ->resourceInfo.base);
++            Rm_osalLog("    Resource length:    %d\n", transactionQ->resourceInfo.length);
++            Rm_osalLog("    Resource alignment: %d\n", transactionQ->resourceInfo.alignment);
++            Rm_osalLog("    Resource NS name:   %s\n", transactionQ->resourceInfo.nameServerName);
++            Rm_osalLog("\n");
++            transactionQ = transactionQ->nextTransaction;
++        }    
++    }
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      This function returns an RM handle to the application to provide
-  *      to LLDs that want to use the RM.
-  *
-  *  @retval
-  *      Success -   RM Handle.  Used an an input parameter for LLD startCfg functions.
-  *  @retval
-  *      Failure -   NULL
++/* FUNCTION PURPOSE: RM instance creation and initialization
++ ***********************************************************************
++ * DESCRIPTION: Returns a new RM instance created and initialized
++ *              using the parameters provided via the initCfg
++ *              structure.
 + */
- Rm_Handle Rm_getHandle(void)
++Rm_Handle Rm_init(Rm_InitCfg *initCfg, int32_t *result)
 +{
-    return ((void *) &rmPermissionCheckers);
++    Rm_Inst *rmInst;
++    void    *globalResourceDtb = NULL;
++    void    *linuxResourceDtb = NULL;
++    bool     addLinux = false;
++
++    *result = RM_OK;
++    
++    if ((initCfg->instName == NULL) ||
++        ((strlen(initCfg->instName) + 1) > RM_NAME_MAX_CHARS)) {
++        *result = RM_ERROR_INVALID_INST_NAME;
++        return (NULL);
++    }
++
++    if (initCfg->instType >= Rm_instType_LAST) {
++        *result = RM_ERROR_INVALID_INST_TYPE;
++    }
++
++    /* Create and initialize instance */
++    rmInst = Rm_osalMalloc (sizeof(Rm_Inst));
++    memset ((void *) rmInst, 0, sizeof(Rm_Inst));
++    rmInst->isLocked = false;
++    rmInst->registeredWithDelegateOrServer = false;
++    rmInst->transactionSeqNum = transactionInitSequenceNum();
++
++    rmInst->instType = initCfg->instType;    
++    strncpy (rmInst->instName, initCfg->instName, RM_NAME_MAX_CHARS);
++
++    if (rmInst->instType == Rm_instType_SERVER) {
++        if (!initCfg->instCfg.serverCfg.globalResourceList ||
++            !initCfg->instCfg.serverCfg.globalPolicy) {
++            *result = RM_ERROR_INVALID_SERVER_CONFIGURATION;
++            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
++            return(NULL);
++        }
++
++        rmInst->policy = initCfg->instCfg.serverCfg.globalPolicy;
++        fdt_open_into(rmInst->policy, rmInst->policy, fdt_totalsize(rmInst->policy)); 
++
++        if (initCfg->instCfg.serverCfg.linuxDtb) {
++            linuxResourceDtb = initCfg->instCfg.serverCfg.linuxDtb;
++            fdt_open_into(linuxResourceDtb, linuxResourceDtb, fdt_totalsize(linuxResourceDtb));
++            addLinux = true;
++        }
++
++        /* Create valid instance list from policy.  Must be done prior to parsing
++         * GRL so that Linux resources can be reserved correctly */
++        rmInst->validInstances = rmPolicyCreateValidInstTree(rmInst->policy, addLinux, result);
++        /* Validate policy assignment strings */
++        *result = rmPolicyValidatePolicy(rmInst->policy, rmInst->validInstances);  
++
++        rmInst->nameServer = rmNameServerInit();
++
++        globalResourceDtb = initCfg->instCfg.serverCfg.globalResourceList;
++        fdt_open_into(globalResourceDtb, globalResourceDtb, fdt_totalsize(globalResourceDtb));
++
++        if ((*result = initializeAllocators(rmInst, globalResourceDtb, linuxResourceDtb)) == RM_OK) {  
++            *result = rmPolicyValidatePolicyResourceNames(rmInst->policy, (void *)rmInst->allocators);
++        }
++        if (*result < RM_OK) {
++            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
++            return(NULL);
++        }
++    }
++
++    if ((rmInst->instType == Rm_instType_CLIENT) && 
++        (initCfg->instCfg.clientCfg.staticPolicy)) {
++        rmInst->staticInfo.staticPolicy = initCfg->instCfg.clientCfg.staticPolicy; 
++    }
++    else if ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&
++             (initCfg->instCfg.cdCfg.staticPolicy)) { 
++        rmInst->staticInfo.staticPolicy = initCfg->instCfg.cdCfg.staticPolicy; 
++    }
++    if (rmInst->staticInfo.staticPolicy) {
++        fdt_open_into(rmInst->staticInfo.staticPolicy, rmInst->staticInfo.staticPolicy, 
++                      fdt_totalsize(rmInst->staticInfo.staticPolicy));       
++        rmInst->staticInfo.staticValidInstTree = rmPolicyCreateValidInstTree(rmInst->staticInfo.staticPolicy, 
++                                                                             addLinux, result);        
++        if (*result == RM_OK) {
++            /* Validate policy assignment strings */
++            *result = rmPolicyValidatePolicy(rmInst->staticInfo.staticPolicy, rmInst->staticInfo.staticValidInstTree);
++        }
++        if (*result != RM_OK) {
++            if (rmInst->staticInfo.staticValidInstTree) {
++                rmPolicyFreeValidInstTree(rmInst->staticInfo.staticValidInstTree);
++            }
++            Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
++            rmInst = NULL;
++        }
++    }
++    return ((Rm_Handle) rmInst);
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      The function is used to get the version information of the RM LLD.
-  *
-  *  @retval
-  *      Version Information.
++/* FUNCTION PURPOSE: Returns RM version information
++ ***********************************************************************
 + */
 +uint32_t Rm_getVersion (void)
 +{
-     return RM_LLD_VERSION_ID;
++    return RM_VERSION_ID;
 +}
 +
- /**
-  *  @b Description
-  *  @n  
-  *      The function is used to get the version string for the RM LLD.
-  *
-  *  @retval
-  *      Version String.
++/* FUNCTION PURPOSE: Returns RM version string
++ ***********************************************************************
 + */
 +const char* Rm_getVersionStr (void)
 +{
-     return rmLldVersionStr;
++    return rmVersionStr;
 +}
 +
- /**
- @}
- */