Checking in RMv2 progress
[keystone-rtos/rm-lld.git] / src / rm.c
index 607eab17b6ed8d8788bbbcd02cf1abd76bd12e61..8f54b2ef90baf6e45a0182c10062bdd3418fb417 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
@@ -2,7 +2,7 @@
  *   @file  rm.c
  *
  *   @brief   
- *      This is the Resource Manager Low Level Driver file.
+ *      This is the Resource Manager source.
  *
  *  \par
  *  ============================================================================
  *  \par
 */
 
-/* c99 include */
-#include <stdint.h>
-#include <stdlib.h>
+/* RM Types */
+#include <ti/drv/rm/rm_types.h>
 
 /* RM 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/rm_services.h>
+#include <ti/drv/rm/rm_transport.h>
+#include <ti/drv/rm/rm_policy.h>
 #include <ti/drv/rm/include/rm_pvt.h>
 
 /* RM OSAL layer */
 #include <rm_osal.h>
 
-/* CSL includes */
-#include <ti/csl/csl_qm_queue.h>
-
 /**********************************************************************
  ************************** Globals ***********************************
  **********************************************************************/
 #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 = 
-{
-    {
-        RM_PERMISSION_TABLE_NOT_VALID,
-    }
-};
-
-/* Create, populate, and place RM global permissions object */
-#pragma DATA_SECTION (rmGPermsObj, ".rm");
-#pragma DATA_ALIGN (rmGPermsObj, 128)
-Rm_GlobalPermissionsObj rmGPermsObj = 
-{
-    {
-        /* 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           
-            }
-        },
-        /* paFirmwarePerms */
-        {
-            0u,
-            0u,
-        },  
-        /* Pointer: paLutPerms */
-        &rmPaLutPerms[0],
-    }
-};
-
-/** @brief Global Variable (should be local per DSP) containing LLD RM permission checkers */
-Rm_LldPermCallouts rmPermissionCheckers = 
-{
-    Rm_initPermissionChecker,
-    Rm_usePermissionChecker,
-};
 
-/** @brief Global Variable which describes the RM LLD Version Information */
-const char   rmLldVersionStr[] = RM_LLD_VERSION_STR ":" __DATE__  ":" __TIME__;
+/** @brief Global Variable which describes the RM Version Information */
+const char   rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;
 
 /**********************************************************************
  ********************** Internal Functions *********************************
  **********************************************************************/
 
-/**
- *  @b Description
- *  @n  
- *      Initialize the permission tables.  All resources are intialized to deny all initialization
- *      and usage permissions.
- *
- */
-void Rm_permissionTableInit(void)
+Rm_TransactionResult rmTransactionForwarder (void *rmHandle, Rm_Transaction *transInfo,
+                                                         Rm_TransactionReceipt *transReceipt)
 {
-    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;
-    }
-    /* Writeback the qmssPdspFirmwarePerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssPdspFirmwarePerms, sizeof (Rm_Perms)*RM_QMSS_FIRMWARE_PDSPS);
+    Rm_Inst *rmInst = (Rm_Inst *) rmHandle;
+    Rm_TransRouteMapNode *routeMap = (Rm_TransRouteMapNode *) rmInst->routeMap;
+    Rm_ProtocolPkt *rmPkt = NULL;
 
-    /* QMSS queues */
-    for (resourceIndex = 0; resourceIndex < RM_QMSS_QUEUES; resourceIndex++)
+    /* Error if no transports have been registered and a service has been requested that
+     * must be forwarded to another RM agent */
+    if (routeMap == NULL)
     {
-        rmGPermsObj.obj.qmssQueuePerms[resourceIndex].initPerms = 0;
-        rmGPermsObj.obj.qmssQueuePerms[resourceIndex].usePerms = 0;
+        return (-1); /* temp error */
     }
-    /* Writeback the qmssQueuePerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssQueuePerms, sizeof (Rm_Perms)*RM_QMSS_QUEUES);
-
-    /* QMSS memory regions */
-    for (resourceIndex = 0; resourceIndex < RM_QMSS_MEM_REGIONS; resourceIndex++)
+    
+    /* Make sure the RM instance has a transport registered with a higher level agent */
+    if (!rmInst->registeredWithDelegateOrServer)
     {
-        rmGPermsObj.obj.qmssMemRegionPerms[resourceIndex].initPerms = 0;
-        rmGPermsObj.obj.qmssMemRegionPerms[resourceIndex].usePerms = 0;
+        return (-1); /* temp error - can't handle request because client delegate or server not registered */
     }
-    /* Writeback the qmssMemRegionPerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssMemRegionPerms, sizeof (Rm_Perms)*RM_QMSS_MEM_REGIONS);
 
-    /* QMSS Linking RAM */
-    for (resourceIndex = 0; resourceIndex < RM_QMSS_LINKING_RAM_RANGES; resourceIndex++)
+    /* Parse the RM instance's routing map to find the higher level agent for forwarding */
+    while ((routeMap->remoteInstType != Rm_instType_CLIENT_DELEGATE) || 
+              (routeMap->remoteInstType != Rm_instType_SERVER))
     {
-        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;
+        /* Traverse the list until arriving at the upper level agent node */
+        routeMap = routeMap->nextNode;
     }
-    /* 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++)
+    /* Create a RM packet using the service information */
+    if (rmInst->transport.rmAllocPkt)
     {
-        rmGPermsObj.obj.qmssAccumChPerms[resourceIndex].initPerms = 0;
-        rmGPermsObj.obj.qmssAccumChPerms[resourceIndex].usePerms = 0;
+        rmPkt = rmInst->transport.rmAllocPkt (routeMap->transHandle, sizeof(Rm_ProtocolPkt));
     }
-    /* Writeback the qmssAccumChPerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssAccumChPerms, sizeof (Rm_Perms)*RM_QMSS_ACCUM_CH);
 
-    /* QMSS QOS Clusters */
-    for (resourceIndex = 0; resourceIndex < RM_QMSS_QOS_CLUSTER; resourceIndex++)
+    /* Return error if the packet allocation API is not plugged or if a NULL packet pointer
+     * was returned */
+    if (!rmPkt)
     {
-        rmGPermsObj.obj.qmssQosClusterPerms[resourceIndex].initPerms = 0;
-        rmGPermsObj.obj.qmssQosClusterPerms[resourceIndex].usePerms = 0;
+        return (-1); /* temp error */
     }
-    /* 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;
-    }
-    /* Writeback the qmssQosQueuePerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.qmssQosQueuePerms, sizeof (Rm_Perms)*RM_QMSS_QOS_QUEUES);      
+    /* Populate the RM packet using the service information */
 
-    /* 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;
-        }
 
-        /* Writeback each of the transmit channel arrays  */
-        Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaTxCh[dmaNum]);
-    }
 
-    /* CPPI DMA receive channels */
-    for (dmaNum = 0; dmaNum < RM_CPPI_MAX_DMAS; dmaNum++)
-    {
-        resArrayPtr = rmGPermsObj.obj.cppiRxChPerms.dmaPermPtrs[dmaNum];
-        
-        for (resourceIndex = 0; resourceIndex < dmaRxCh[dmaNum]; resourceIndex++)
-        {
-            resArrayPtr[resourceIndex].initPerms = 0;
-            resArrayPtr[resourceIndex].usePerms = 0;
-        }
-
-        /* Writeback each of the receive channel arrays */
-        Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaRxCh[dmaNum]);
-    }    
-
-    /* CPPI DMA flows */
-    for (dmaNum = 0; dmaNum < RM_CPPI_MAX_DMAS; dmaNum++)
-    {
-        resArrayPtr = rmGPermsObj.obj.cppiFlowPerms.dmaPermPtrs[dmaNum];
-        
-        for (resourceIndex = 0; resourceIndex < dmaFlow[dmaNum]; resourceIndex++)
-        {
-            resArrayPtr[resourceIndex].initPerms = 0;
-            resArrayPtr[resourceIndex].usePerms = 0;
-        }
+    /* Inform component that requested the service that the resource is being requested
+     * from the higher level RM agent.  The component must assume the resource service
+     * result will be returned using the specified callback function */
+    return (RM_REQUESTING_RESOURCE);
+}
 
-        /* Writeback each of the flow arrays */
-        Rm_osalEndMemAccess ((void *) resArrayPtr, sizeof (Rm_Perms)*dmaFlow[dmaNum]);
-    }       
+Rm_TransactionResult rmTransactionProcessor (rmHandle, Rm_Transaction *newTransaction, 
+                                                               Rm_TransactionReceipt *newTransactionReceipt)
+{
 
-    /* PA Lookup tables */
-    for (resourceIndex = 0; resourceIndex < RM_PA_LUT; resourceIndex++)
-    {
-        rmGPermsObj.obj.paLutPerms[resourceIndex].initPerms = 0;
-        rmGPermsObj.obj.paLutPerms[resourceIndex].usePerms = 0;
-    }
-    /* Writeback the paLutPerms array */
-    Rm_osalEndMemAccess ((void *) rmGPermsObj.obj.paLutPerms, sizeof (Rm_Perms)*RM_PA_LUT);
-    
 }
 
-/**
- *  @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.
- */
-void Rm_setTablePermissions (const Rm_Resource *resourceEntry, Rm_Perms *rmPermsArray, uint32_t len)
+Rm_ServiceResult rmServiceHandler (void *rmHandle, Rm_ServiceReqInfo *requestInfo,
+                                                               Rm_ServiceRespInfo *responseInfo)
 {
-    uint32_t index;
+    Rm_Inst *rmInst = (Rm_Inst *) rmHandle;
+    Rm_Transaction newTransaction;
+    Rm_TransactionReceipt newTransactionReceipt;
+    Rm_ServiceResult retVal = RM_service_OKAY;
+    void *key;
+
+    /* Prevent another component using the same instance from wiping out the current
+     * service request */
+    key = Rm_osalLocalCsEnter();
+
+    /* Transfer request information into the internal transaction format */
+    newTransaction.transType = (Rm_Command) requestInfo->serviceType;
+    /* Policy modifications will never originate from components */
+    strcpy ((void *) &(newTransaction.u.transInfo.resName)[0], (void *)requestInfo->resName);
+    newTransaction.u.transInfo.resBase = requestInfo->resourceAlign;
+    newTransaction.u.transInfo.resNum = requestInfo->resourceNum;
+    newTransaction.u.transInfo.resAlign = requestInfo->resourceAlign;
+    strcpy ((void *) &(newTransaction.u.transInfo.resNsName)[0], (void *)requestInfo->resNsName);
+
+    /* All service requests on Clients are forwarded to the higher level RM agent
+     * either a Client Delegate or Server, based on the RM system architecture */
+    if (rmInst->instType == Rm_instType_CLIENT)
+    {
+        retVal = (Rm_ServiceResult) rmTransactionForwarder (rmHandle, &newTransaction, &newTransactionReceipt);
 
-    /* Scan through the resource range filling in the specified permission */
-    for (index = resourceEntry->resourceStart; index < resourceEntry->resourceEnd + 1; index++)
+        /* Copy internal transaction receipt information into the response info fields for the 
+         * component */
+        responseInfo->requestId = newTransactionReceipt.transactionId;
+        responseInfo->resBase = newTransactionReceipt.resBase;
+        responseInfo->resNum = newTransactionReceipt.resNum;
+    }
+    else
     {
-        rmPermsArray[index].initPerms = resourceEntry->resourceInitFlags;
-        rmPermsArray[index].usePerms  = resourceEntry->resourceUseFlags;
+        /* Directly handle the request if on a Client Delegate or Server.  On Client Delegates, if
+         * the request cannot be serviced it will be forwarded to the higher level RM instance. */
+        retVal = (Rm_ServiceResult) rmTransactionProcessor (rmHandle, &newTransaction, &newTransactionReceipt);
+
+        /* Copy internal transaction receipt information into the response info fields for the 
+         * component */
+        responseInfo->requestId = newTransactionReceipt.transactionId;
+        responseInfo->resBase = newTransactionReceipt.resBase;
+        responseInfo->resNum = newTransactionReceipt.resNum;
     }
 
-    Rm_osalEndMemAccess ((void *)rmPermsArray, sizeof (Rm_Perms)* len);
+    Rm_osalLocalCsExit(key);
+    
+    return (retVal);
 }
 
-/**
- *  @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
- */
-Rm_Result Rm_populatePermissionTable(const Rm_Resource *rmResourceTable)
+/**********************************************************************
+ *********************** Application visible APIs ***************************
+ **********************************************************************/
+
+Rm_Handle Rm_init(Rm_InitCfg *initCfg)
 {
-    const Rm_Resource *resourceEntry;
-    uint16_t linkRamIndex;
+    Rm_Inst *rmInst;
 
-    /* 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)
+    /* Instance creation checks.  Add one to strlen calculation for null character */
+    if ((strlen(initCfg->instName) + 1) > RM_INSTANCE_NAME_MAX_CHARS)
     {
-        return RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED;
+        /* Failure: Instance name is too big */
+        return (NULL);
     }
+    
+    /* Get memory for RM instance from local memory */
+    rmInst = Rm_osalMalloc (sizeof(Rm_Inst), false);
+    /* Populate instance based on input parameters */
+    strcpy (&rmInst->name[0], initCfg->instName);
+    rmInst->instType = initCfg->instType;
+    rmInst->instState = RM_state_IDLE;
+    rmInst->registeredWithDelegateOrServer = false;
+    rmInst->serviceCallback = NULL;
+
+    /* Populate the instance transport callouts */
+    rmInst->transport.rmAllocPkt = initCfg->rmAllocPktFuncPtr;
+    rmInst->transport.rmFreePkt = initCfg->rmFreePktFuncPtr;
+    rmInst->transport.rmSend = initCfg->rmSendFuncPtr;
+    rmInst->transport.rmReceive = initCfg->rmReceiveFuncPtr;
+    rmInst->transport.rmNumPktsReceived = initCfg->rmNumPktsReceivedFuncPtr;
+
+    /* Initialize the transport routing map linked list pointer to NULL.  The linked list
+      * nodes will be created when the application registers transports */
+    rmInst->routeMap = NULL;
+
+    /* RM Server specific actions */
+    if (rmInst->instType == Rm_instType_SERVER)
+    {
 
-    /* Magic number is visible start parsing the resource table and transferring
-      * permissions to the internal permissions tables */
+    }
 
-    /* Parse resource table until last entry field is encountered */
-    while (resourceEntry->resourceId != RM_RESOURCE_FINAL_ENTRY)
+    /* Instance startup policies are only used for Servers and Client Delegates */
+    if (rmInst->instType != Rm_instType_CLIENT)
     {
-        /* 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;
+        rmInst->instPolicy = initCfg->startupPolicy;
 
-        }
+        /* Store policy via policy APIs ... */
+    }
 
-        resourceEntry++;
-    };
+    /* Return the RM Handle */
+    return ((Rm_Handle) rmInst);
+}
 
-    /* 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));
+Rm_Result Rm_preMainAllocResource(Rm_PreMainAllocInfo 
+                                                   *preMainAllocInfo)
+{
 
-    return RM_OK;
 }
 
-/**
- *  @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
- *
- */
-void Rm_updatePermissionTables(void)
+Rm_ServiceHandle Rm_getServiceHandle(Rm_Handle rmHandle)
 {
-    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_Inst *rmInst = (Rm_Inst *) rmHandle;
+    Rm_ServicesPort *newServicePort;
     
-    /* Invalidate all permission tables so no further invalidates are required
-      * on slave cores */
-
-    /* Global permissions object */
-    Rm_osalBeginMemAccess ((void *) &rmGPermsObj, sizeof (Rm_GlobalPermissionsObj));
+    /* Create a new service handle for the specified RM instance */
     
-    /* 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]); 
-    }
-    /* 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]); 
-    }
-    /* 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]); 
-    }
+    /* Get memory for a new service port from local memory */
+    newServicePort = Rm_osalMalloc (sizeof(Rm_ServicesPort), false);
 
-    /* PA permission tables */
+    newServicePort->rmHandle = rmHandle;
+    newServicePort->rmService = rmServiceHandler;
 
-    /* PA Firmware invalidated as part of global permissions object invalidate */
-    /* PA LUTs */
-    Rm_osalBeginMemAccess ((void *)rmGPermsObj.obj.paLutPerms, sizeof (Rm_Perms) * RM_PA_LUT);   
+    return ((Rm_ServiceHandle) newServicePort);
 }
 
-/**
- *  @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
- */
-Rm_Result Rm_getInitPermissions (Rm_Perms *resourcePermissions)
+Rm_TransportHandle Rm_registerTransport (Rm_Handle rmHandle, 
+                                     Rm_TransCfg *transCfg)
 {
-    /* Check the init permissions for the calling DSP */
-    if (!(RM_GET_PERMISSIONS(resourcePermissions->initPerms)))
+    Rm_Inst *rmInst = (Rm_Inst *) rmHandle;
+    Rm_TransRouteMapNode *existingRouteMap = (Rm_TransRouteMapNode *) rmInst->routeMap;
+    Rm_TransRouteMapNode *newRouteMapNode;
+
+    /* RM Servers cannot connect to other Servers */
+    if ((rmInst->instType == Rm_instType_SERVER) &&
+         (transCfg->rmRemoteInstType == Rm_instType_SERVER))
     {
-        return RM_INIT_PERMISSION_DENIED;
+        return (NULL); /* Error -return null */
     }
-  
-    return RM_INIT_PERMISSION_APPROVED;
-}
 
-/**
- *  @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
- */
-Rm_Result Rm_getUsePermissions (Rm_Perms *resourcePermissions)
-{
-    /* Check the use permissions for the calling DSP */
-    if (!(RM_GET_PERMISSIONS(resourcePermissions->usePerms)))
+    /* Verify Clients and Client Delegates are not registering with more than one Client Delegate or Server.
+     * Assuming a Client Delegate can register with another Client Delegate that can "act" as a server */
+    if (((rmInst->instType == Rm_instType_CLIENT) || (rmInst->instType == Rm_instType_CLIENT_DELEGATE)) &&
+         ((transCfg->rmRemoteInstType == Rm_instType_CLIENT_DELEGATE) ||
+           (transCfg->rmRemoteInstType == Rm_instType_SERVER)) &&
+          rmInst->registeredWithDelegateOrServer)
     {
-        return RM_USE_PERMISSION_DENIED;
-    }
-  
-    return RM_USE_PERMISSION_APPROVED;
-}
+        return (NULL); /* Error -return null */
+    }         
 
-/**
- *  @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
- */
-Rm_Result Rm_getLinkRamPermissions (Bool isInitCheck, Rm_qmssLinkingRamPerms *linkRamPermArray, Rm_ResourceInfo *linkRamResData)
-{
-    Rm_Result retVal;
-    uint16_t linkRamIndex;
+    /* Error checks passed - Create a new transport handle for the specified RM instance */
+    
+    /* Get memory for a new routing map node from local memory */
+    newRouteMapNode = Rm_osalMalloc (sizeof(Rm_TransRouteMapNode), false);
+
+    /* Populate the new node.  The address of the node itself is stored since this address is returned
+     *  to the application as the Rm_TransportHandle */
+    newRouteMapNode->transHandle = newRouteMapNode;
+    newRouteMapNode->remoteInstType = transCfg->rmRemoteInstType;
+    newRouteMapNode->nextNode = NULL;  /* New node will always be NULL */
 
-    /* Initialize the return value based on type of check boolean */
-    if (isInitCheck)
+    /* Check if there are any entries in the routing map */
+    if (existingRouteMap)
     {
-        retVal = RM_INIT_PERMISSION_DENIED;
+        /* At least one entry in the routing map.  Add the new routing map node to the end of the
+         * routing map node list */
+        while (existingRouteMap->nextNode != NULL)
+        {
+            /* Traverse the list until arriving at the last node */
+            existingRouteMap = existingRouteMap->nextNode;
+        }
+
+        /* Add the new node to the end of the list */
+        existingRouteMap->nextNode = newRouteMapNode;
     }
     else
     {
-        retVal = RM_USE_PERMISSION_DENIED;
+        /* A routing map does not currently exist.  The new node is the first entry */
+        rmInst->routeMap = newRouteMapNode;
     }
-    
-    for (linkRamIndex = 0; linkRamIndex < RM_QMSS_LINKING_RAM_RANGES; linkRamIndex++)
+
+    /* Specify RM instance has registered with a higher level agent */
+    if ((newRouteMapNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||
+         (newRouteMapNode->remoteInstType == Rm_instType_SERVER))
     {
-        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;
-                }
-            }
-            else
-            {
-                if (RM_GET_PERMISSIONS(linkRamPermArray[linkRamIndex].rangePerms.usePerms))
-                {
-                    retVal = RM_USE_PERMISSION_APPROVED;
-                }
-            }
-            break;
-        }
+        rmInst->registeredWithDelegateOrServer = true;
     }
 
-    return (retVal);
+    return ((Rm_TransportHandle) newRouteMapNode);
 }
 
-/**********************************************************************
- **********APIs visible to other LLDs internally via call table *******************
- **********************************************************************/
-
-/**
- *  @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
- */
-Rm_Result Rm_initPermissionChecker (Rm_ResourceInfo *resourceData)
+Rm_Result Rm_unregisterTransport (Rm_Handle rmHandle, Rm_TransportHandle transHandle)
 {
-    switch (resourceData->resourceType)
+    Rm_Inst *rmInst = (Rm_Inst *) rmHandle;
+    Rm_TransRouteMapNode *routeMapNode = (Rm_TransRouteMapNode *) rmInst->routeMap;
+    Rm_TransRouteMapNode *prevNode = NULL;
+
+    /* Make sure a routing map exists for the RM instance */
+    if (!routeMapNode)
     {
-        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]));
-
-        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]));  
-
-        case Rm_resource_QMSS_QOS_TIMER:
-            return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQosPdspTimerPerms));   
-
-        case Rm_resource_QMSS_QOS_CLUSTER:
-            return (Rm_getInitPermissions(&rmGPermsObj.obj.qmssQosClusterPerms[resourceData->res_info.qosCluster]));           
-
-        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]));       
-            }
-            
-        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);
+        return (-1); /* TEMP ERROR RETURN */
     }
-}
 
-/**
- *  @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
- */
-Rm_Result Rm_usePermissionChecker (Rm_ResourceInfo *resourceData)
-{
-    switch (resourceData->resourceType)
+    /* Find the transport handle within the specified RM instance's routing map. */
+    while (1)
     {
-        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]));
-
-        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]));     
-
-        case Rm_resource_QMSS_QOS_TIMER:
-            return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQosPdspTimerPerms));   
-
-        case Rm_resource_QMSS_QOS_CLUSTER:
-            return (Rm_getUsePermissions(&rmGPermsObj.obj.qmssQosClusterPerms[resourceData->res_info.qosCluster]));           
-
-        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]));
-            }
-            
-        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]));       
-            }
-            
-        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);
+         if (routeMapNode->transHandle == transHandle)
+         {
+             /* Match: break out of loop and delete the node */
+             break;             
+         }
+         else if (routeMapNode->nextNode == NULL)
+         {
+             return (-1); /* TEMP ERROR: transhandle does not exist for RM instance */
+         }
+
+         prevNode = routeMapNode;
+         routeMapNode = routeMapNode->nextNode;
     }
-}
-
-/*  */
-
-/**********************************************************************
- *********************** 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
- */
-Rm_Result Rm_init (const Rm_Resource *rmResourceTable)
-{
-    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();
-
-    if (!rmResourceTable)
+    /* Delete the routing map node */
+    if ((prevNode == NULL) && routeMapNode->nextNode)
     {
-        /* End Critical Section */
-        Rm_osalCsExit (key);
-        return RM_ERROR_PERMISSION_TABLE_POPULATION_FAILED;
+        /* Node to be deleted exists at start of route map.  Map second node to be start of
+         * node list as long as there are more than one routing map nodes */
+        rmInst->routeMap = routeMapNode->nextNode;
+    }
+    else
+    {
+        /* Node to be deleted is in the middle or at end of the list.  Adjust adjacent
+         * nodes pointers.  This covers the case where the node to be removed is at the
+         * end of the list. */
+        prevNode->nextNode = routeMapNode->nextNode;
     }
 
-    ret_val = Rm_populatePermissionTable(rmResourceTable);
-
-    /* End Critical Section */
-    Rm_osalCsExit (key);
-    return ret_val;
-}
-
-/**
- *  @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
- */
-Rm_Result Rm_start (void)
-{
-    /* Loop until the global sync object signals the permissions table has been
-      * populated and valid */
-    do
+    /* Remove specification in RM instance that it has been connected to an upper level agent
+     * if the node to be deleted has a remote instance type of Client Delegate or Server */
+    if ((routeMapNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||
+         (routeMapNode->remoteInstType == Rm_instType_SERVER))
     {
-        /* Invalidate the global sync object */
-        Rm_osalBeginMemAccess ((void *) &rmGSyncObj, sizeof (Rm_Sync_Obj));
-    } while (rmGSyncObj.obj.globalSyncObj != RM_PERMISSION_TABLE_VALID);
+        rmInst->registeredWithDelegateOrServer = false;
+    }
 
-    /* Master core finished populating the permission tables.  Must invalidate
-      * all tables to see latest permissions */
-    Rm_updatePermissionTables();
+    /* Delete the node, free the memory associated with the node. */
+    Rm_osalFree((void *) routeMapNode, sizeof(Rm_TransRouteMapNode), false);
 
-    return RM_OK;
+    return (RM_OK);
 }
 
-/**
- *  @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
- */
-Rm_Handle Rm_getHandle(void)
+
+Rm_TransVerifyResult Rm_verifyTransport (Rm_Handle, uint32_t timeout, 
+                                         Rm_TransFailData *failData)
 {
-   return ((void *) &rmPermissionCheckers);
+
 }
 
-/**
- *  @b Description
- *  @n  
- *      The function is used to get the version information of the RM LLD.
- *
- *  @retval
- *      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.
- */
+
 const char* Rm_getVersionStr (void)
 {
-    return rmLldVersionStr;
+    return rmVersionStr;
 }
 
 /**