Checking in RMv2 progress
authorJustin Sobota <jsobota@ti.com>
Mon, 29 Oct 2012 15:18:18 +0000 (11:18 -0400)
committerJustin Sobota <jsobota@ti.com>
Mon, 29 Oct 2012 15:18:18 +0000 (11:18 -0400)
include/rm_pvt.h
rm.h
rm_osal.h
rm_policy.h [new file with mode: 0644]
rm_public.h [deleted file]
rm_services.h [new file with mode: 0644]
rm_transport.h [new file with mode: 0644]
rm_types.h [new file with mode: 0644]
rmver.h.xdt
src/rm.c

index 029b67171a1b71be35207fa3215404b996bcfe86..bbb1016f513ccad7b24665b3cf9df6dffdcf5f83 100644 (file)
@@ -1,7 +1,7 @@
 /*
  *  file  rm_pvt.h
  *
- *  Private data structures of Resource Manager Low Level Driver.
+ *  Private data structures of Resource Manager.
  *
  *  ============================================================================
  *      (C) Copyright 2012, Texas Instruments, Inc.
@@ -48,158 +48,9 @@ extern "C" {
 #include <c6x.h>
 
 /* RM includes */
-#include <ti/drv/rm/rm_public_lld.h>
-
-/* CSL includes */
-#include <ti/csl/csl_qm_queue.h>
-
-/* QMSS Resource Information */
-#define RM_QMSS_FIRMWARE_PDSPS 2
-#define RM_QMSS_QUEUES 8192
-#define RM_QMSS_MEM_REGIONS 20
-#define RM_QMSS_LINKING_RAM_RANGES 40 /* Twice as many memory regions */
-#define RM_QMSS_ACCUM_CH 48
-#define RM_QMSS_QOS_CLUSTER 8
-#define RM_QMSS_QOS_QUEUES 64
-
-#define RM_QMSS_LINKING_RAM_RANGE_INIT  (0xFFFFFFFF)
-
-/* CPPI Resource Information */
-
-/* Set CPPI DMA increments based on which DMAs are present for the device */
-
-/* Set AIF increment if present */
-#ifdef QMSS_MAX_AIF_QUEUE
-#define RM_CPPI_AIF_INC 1
-#else
-#define RM_CPPI_AIF_INC 0
-#endif
-/* Set FFTC A increment if present */
-#ifdef QMSS_MAX_FFTC_A_QUEUE
-#define RM_CPPI_FFTC_A_INC 1
-#else
-#define RM_CPPI_FFTC_A_INC 0
-#endif
-/* Set FFTC B increment if present */
-#ifdef QMSS_MAX_FFTC_B_QUEUE
-#define RM_CPPI_FFTC_B_INC 1
-#else
-#define RM_CPPI_FFTC_B_INC 0
-#endif
-/* Set PASS increment if present */
-#ifdef QMSS_MAX_PASS_QUEUE
-#define RM_CPPI_PASS_INC 1
-#else
-#define RM_CPPI_PASS_INC 0
-#endif
-/* Set FFTC C increment if present */
-#ifdef QMSS_MAX_FFTC_C_QUEUE
-#define RM_CPPI_FFTC_C_INC 1
-#else
-#define RM_CPPI_FFTC_C_INC 0
-#endif
-/* Set BCP increment if present */
-#ifdef QMSS_MAX_BCP_QUEUE
-#define RM_CPPI_BCP_INC 1
-#else
-#define RM_CPPI_BCP_INC 0
-#endif
-
-/* Base number of DMAs for all devices. */
-#define RM_CPPI_BASE_DMAS 2
-/* Set max DMAs, adding additional DMAs if present */
-#define RM_CPPI_MAX_DMAS (RM_CPPI_BASE_DMAS + RM_CPPI_AIF_INC + RM_CPPI_FFTC_A_INC + \
-                                                RM_CPPI_FFTC_B_INC + RM_CPPI_PASS_INC + RM_CPPI_FFTC_C_INC + \
-                                                RM_CPPI_BCP_INC)
-
-/* Set DMA indices based on which DMAs are present in device */
-#define RM_CPPI_SRIO_DMA_ID 0
-#define RM_CPPI_AIF_DMA_ID (RM_CPPI_SRIO_DMA_ID + RM_CPPI_AIF_INC)
-#define RM_CPPI_FFTC_A_DMA_ID (RM_CPPI_AIF_DMA_ID + RM_CPPI_FFTC_A_INC)
-#define RM_CPPI_FFTC_B_DMA_ID (RM_CPPI_FFTC_A_DMA_ID + RM_CPPI_FFTC_B_INC)
-#define RM_CPPI_PASS_DMA_ID (RM_CPPI_FFTC_B_DMA_ID + RM_CPPI_PASS_INC)
-#define RM_CPPI_QMSS_DMA_ID (RM_CPPI_PASS_DMA_ID + 1)
-#define RM_CPPI_FFTC_C_DMA_ID (RM_CPPI_QMSS_DMA_ID + RM_CPPI_FFTC_C_INC)
-#define RM_CPPI_BCP_DMA_ID (RM_CPPI_FFTC_C_DMA_ID + RM_CPPI_BCP_INC)
-
-#define RM_CPPI_SRIO_TX_CH 16
-#define RM_CPPI_AIF_TX_CH 129
-#define RM_CPPI_FFTC_A_TX_CH 4
-#define RM_CPPI_FFTC_B_TX_CH 4
-#define RM_CPPI_PASS_TX_CH 9
-#define RM_CPPI_QMSS_TX_CH 32
-#define RM_CPPI_FFTC_C_TX_CH 4
-#define RM_CPPI_BCP_TX_CH 8
-
-#define RM_CPPI_SRIO_RX_CH 16
-#define RM_CPPI_AIF_RX_CH 129
-#define RM_CPPI_FFTC_A_RX_CH 4
-#define RM_CPPI_FFTC_B_RX_CH 4
-#define RM_CPPI_PASS_RX_CH 24
-#define RM_CPPI_QMSS_RX_CH 32
-#define RM_CPPI_FFTC_C_RX_CH 4
-#define RM_CPPI_BCP_RX_CH 8
-
-#define RM_CPPI_SRIO_FLOW 20
-#define RM_CPPI_AIF_FLOW 129
-#define RM_CPPI_FFTC_A_FLOW 8
-#define RM_CPPI_FFTC_B_FLOW 8
-#define RM_CPPI_PASS_FLOW 32
-#define RM_CPPI_QMSS_FLOW 64
-#define RM_CPPI_FFTC_C_FLOW 8
-#define RM_CPPI_BCP_FLOW 64
-
-/* PA Resource Information */
-#define RM_PA_LUT 5
-
-/* Permissions Access Defines and Macros */
-#define RM_RESOURCE_PERM_INIT_SHIFT 0
-#define RM_RESOURCE_PERM_USE_SHIFT  1
-
-#define RM_GET_RESOURCE_FLAG(flag) ((flag) >> ((DNUM) << 1))
-
-#define RM_GET_RESOURCE_INIT_FLAG(flag) ((RM_GET_RESOURCE_FLAG (flag) >> RM_RESOURCE_PERM_INIT_SHIFT) & 1)
-#define RM_GET_RESOURCE_USE_FLAG(flag)  ((RM_GET_RESOURCE_FLAG (flag) >> RM_RESOURCE_PERM_USE_SHIFT)  & 1)
-
-#define RM_GET_PERMISSIONS(perms) (perms >> DNUM)
-
-#define RM_RANGE_CHECK(start, end, max, ret_val) \
-do { \
-    if ((start > end) || (end > max)) \
-    { \
-        return ret_val; \
-    } \
-} while(0)
-
-/* RM standard permission structure definition */
-typedef struct
-{
-    /** Initialization permissions
-      * Bit 0 - Core 0 init permission
-      * Bit 1 - Core 1 init permission
-      * Bit 2 - Core 2 init permission
-      * Bit 3 - Core 3 init permission
-      */    
-    uint32_t initPerms;  
-    /** Usage permissions
-      * Bit 0 - Core 0 use permission
-      * Bit 1 - Core 1 use permission
-      * Bit 2 - Core 2 use permission
-      * Bit 3 - Core 3 use permission
-      */    
-    uint32_t usePerms;
-} Rm_Perms;
-
-/* RM permissions structure for Linking RAM regions */
-typedef struct
-{
-    /** Linking RAM start index for these permissions */
-    uint32_t startIndex;
-    /** Linking RAM end index for these permissions */
-    uint32_t endIndex;
-    /** Permissions for the range */
-    Rm_Perms rangePerms;
-} Rm_qmssLinkingRamPerms;
+#include <ti/drv/rm/rm_services.h>
+#include <ti/drv/rm/rm_policy.h>
+#include <ti/drv/rm/rm_transport.h>
 
 /* RM permissions structure for CPPI DMA channels and flows */
 typedef struct
@@ -222,7 +73,7 @@ typedef struct
 
 #define RM_MAX_CACHE_ALIGN 128  /* Maximum alignment for cache line size */
 
-/* This macro generates compilier error if postulate is false, so 
+/* This macro generates compiler error if postulate is false, so 
  * allows 0 overhead compile time size check.  This "works" when
  * the expression contains sizeof() which otherwise doesn't work
  * with preprocessor */
@@ -264,63 +115,170 @@ typedef struct
                        (sizeof(Rm_Sync_Obj_Unpadded) % RM_MAX_CACHE_ALIGN)];
 } Rm_Sync_Obj;
 
+/** Maximum number of characters allowed for instance names */
+#define RM_INSTANCE_NAME_MAX_CHARS 24
+
+
+/** Assigned to the Start/EndIndex entries in the protocol packet to request
+ *  the next available resource instead of a specific index */
+#define RM_NEXT_AVAILABLE_RESOURCE (-1)
+
+/** Maximum size of a transmittable RM policy in bytes */
+#define RM_MAX_POLICY_SIZE_BYTES (64)  // Placeholder: This will change 
+                                       // during development
+
+/* Pointer to RM instance's transport routing map */
+typedef void *Rm_TransRouteMap;
+
+typedef Rm_ServiceResult Rm_TransactionResult;
+
+/**
+ * @brief RM transport routing map linked list node
+ */
+typedef struct {
+    /** Transport handle associated with this node */
+    Rm_TransportHandle transHandle;
+    /** The remote RM instance type associated with this node */
+    Rm_InstType remoteInstType;
+    /** Link to the next route node in the route map list */
+    Rm_TransRouteMapNode *nextNode;
+} Rm_TransRouteMapNode;
+
+/**
+ * @brief RM protocol commands.  The first N commands should be synchronized with
+ *        the Rm_ServiceType enum in rm_service.h
+ */
+typedef enum {
+    /** Resource allocation request */
+    Rm_command_ALLOCATE = Rm_service_RESOURCE_ALLOCATE,
+    /** Block resource allocation request */
+    Rm_command_BLOCK_ALLOCATE = Rm_service_RESOURCE_BLOCK_ALLOCATE,
+    /** Resource allocate by name */
+    Rm_command_ALLOCATE_NAMED = Rm_service_RESOURCE_ALLOCATE_BY_NAME,
+    /** Free resource */
+    Rm_command_FREE = Rm_service_RESOURCE_FREE,
+    /** Free resource block */
+    Rm_command_BLOCK_FREE = Rm_service_RESOURCE_BLOCK_FREE,
+    /** Free named resource */
+    Rm_command_FREE_NAMED = Rm_service_RESOURCE_FREE_BY_NAME,
+    /** Map provided name to specified resource index */
+    Rm_command_MAP_NAME = Rm_service_RESOURCE_MAP_TO_NAME,
+    /** Unmap provided name from tied resource */
+    Rm_command_UNMAP_NAME = Rm_service_RESOURCE_UNMAP_NAME,
+    /** Get the status of the specified resource */
+    Rm_command_RESOURCE_STATUS = Rm_service_RESOURCE_STATUS,
+    /** Policy request */
+    Rm_command_POLICY_REQUEST,
+    /** Policy response */
+    Rm_command_POLICY_RESPONSE
+} Rm_Command;
+
+/**
+ * @brief RM protocol packet resource information
+ */
+typedef struct {
+    /** Resource name of resource affected by command */
+    char resName[RM_MAX_RESOURCE_NAME_SIZE_BYTES];
+    /** If applicable, start of resource range affected by command */
+    int32_t resBase;
+    /** If applicable, number of specified resource affected by command */
+    int32_t resNum;
+    /** If applicable, the alignment of the resource affected by the command */
+    uint32_t resAlign;
+    /** If applicable, the NameServer name assigned to the specified
+     *  resource.  Used for commands centering on RM NameServer actions */
+    char resNsName[RM_MAX_RESOURCE_NAME_SIZE_BYTES];
+} Rm_ResourceInfo;
+
+/**
+ * @brief RM transaction is the internalized version of service requests received 
+ *        from components and RM commands received from other RM instances.
+ */
+typedef struct {
+    /* Transaction type */
+    Rm_Command transType;
+    /* Transaction details */
+    union {
+        /** If the command has to do with resources these fields
+         *  will contain the resource information */
+        Rm_ResourceInfo transInfo;
+        /** Pointer to policy data if the command has to do with policies */
+        char *policyData;
+    } u;
+} Rm_Transaction;
+
+/**
+ * @brief RM transaction contains transaction result information that is to be passed
+ *        back to the entity that was the source of the transaction.  The source can be
+ *        a component that requested a service or a RM instance that sent a command.
+ */
+typedef struct {
+    uint32_t transactionId;
+    uint32_t resBase;
+    uint32_t resNum;
+} Rm_TransactionReceipt;
+
+/**
+ * @brief RM protocol packet used to transmit RM commands and resources
+ *        between RM instances.
+ */
+typedef struct {
+    /** Packet ID - Used to synchronize sent command packets with any valid
+     *              response commands. */
+    uint32_t rmPktId;
+    /** Response Packet ID - If protocol packet is sent as response to a 
+     *                       received packet the response packet ID field will
+     *                       contain the pktID value of the request packet
+     *                       received */
+    uint32_t rmRespPktId;
+    /** RM Instance Name - Name of RM instance that is issuing the command.       
+     *                     The instance name will be used to validate the 
+     *                     command against the instance name data stored in
+     *                     the RM policy data */
+    char rmInstName[RM_INST_NAME_MAX_CHARS];
+    /** Command issued from source RM instance */
+    uint32_t rmCmd;
+    /** Response code provides requesting RM instance with information about
+     *  the result of any requests made */
+    uint32_t rmRespCode;
+    /** Union separating resource information from policy information */
+    union {
+        /** If the command has to do with one or more resources these fields
+         *  will contain the resource information */
+        Rm_ResourceInfo resInfo;
+        /** If the command has to do with a policy this array will hold the
+         *  policy data */
+        char rmPolicyData[RM_MAX_POLICY_SIZE_BYTES];
+    } u;
+} Rm_ProtocolPkt;
+
+typedef enum {
+    /** running */
+    RM_state_IDLE = 0,
+    /** handling request */
+    RM_state_HANDLING_REQUEST = 1,
+    /** etc...flesh all these out later will need states for the different alloc, free, request/response handlers */
+} Rm_State;
+
+typedef struct {
+    char name[RM_INSTANCE_NAME_MAX_CHARS];
+    Rm_InstType instType;
+    Rm_State instState;
+    bool registeredWithDelegateOrServer;
+    Rm_PolicyHandle instPolicy;  /* Client Delegate only? */
+
+    /* RM instance transport parameters */
+    Rm_TransRouteMap routeMap;
+    /* Transport API function pointers - not global in case application wants to
+      * hook up different transports to RM */
+    Rm_TransportCallouts transport;
+    /* Most of the time will be NULL.  Will be NULL if a service request has been made and a callback function
+     * has been specified.  In that case this variable will be populated until the callback is made */
+    void *serviceCallback;
+} Rm_Inst;
+
+Rm_Result Rm_getUsePermissions (Rm_Perms *resourcePermissions);
 
-/* RM Global permissions object definition. (unpadded) */
-typedef struct 
-{
-    /** Store the QMSS PDSP firmware permissions */
-    Rm_Perms *qmssPdspFirmwarePerms;  
-    /** Store a pointer to the QMSS queue permissions array */
-    Rm_Perms *qmssQueuePerms;
-    /** Store a pointer to the QMSS memory region permissions array */
-    Rm_Perms *qmssMemRegionPerms;
-    /** Store the QMSS Linking RAM Control permissions */
-    Rm_Perms qmssLinkRamControlPerms;
-    /** Store a pointer to the QMSS linking RAM permissions list */
-    Rm_qmssLinkingRamPerms *qmssLinkRamPerms;
-    /** Store a pointer to the QMSS accumulator channel permissions array */
-    Rm_Perms *qmssAccumChPerms;
-    /** Store the QMSS QOS PDSP timer permissions */
-    Rm_Perms qmssQosPdspTimerPerms;      
-    /** Store a pointer to the QMSS QOS cluster permissions array */
-    Rm_Perms *qmssQosClusterPerms;    
-    /** Store a pointer to the QMSS QOS queue permissions array */
-    Rm_Perms *qmssQosQueuePerms;       
-    /** Store the structure of pointers to the CPPI transmit channel permissions array */
-    Rm_CppiChAndFlowPerms cppiTxChPerms;
-    /** Store the structure of pointers to the CPPI receive channel permissions array */
-    Rm_CppiChAndFlowPerms cppiRxChPerms;
-    /** Store the structure of pointers to the CPPI flow permissions array */
-    Rm_CppiChAndFlowPerms cppiFlowPerms;
-    /** Store the PA firmware permissions */
-    Rm_Perms paFirmwarePerms;  
-    /** Store a pointer to the PA lookup table permissions array */
-    Rm_Perms *paLutPerms;    
-}Rm_GlobalPermissionsObj_Unpadded;
-
-/* RM Global Permissions Object (padded) */
-typedef struct
-{
-    /** Data structure without padding, so sizeof() can compute padding */
-    Rm_GlobalPermissionsObj_Unpadded obj;
-    /** Pad out to end of RM_MAX_CACHE_ALIGN bytes to prevent something else
-     * from being placed on same cache line as Rm_Synci_Obj.  Note that 
-     * pad[0] is illegal, so must add full RM_MAX_CACHE_ALIGN if structure
-     * is already padded by chance. */
-    uint8_t  pad[RM_MAX_CACHE_ALIGN - 
-                       (sizeof(Rm_GlobalPermissionsObj_Unpadded) % RM_MAX_CACHE_ALIGN)];
-} Rm_GlobalPermissionsObj;
-
-extern void Rm_permissionTableInit(void);
-extern void Rm_setTablePermissions (const Rm_Resource *resourceEntry, Rm_Perms *rmPermsArray, uint32_t len);
-extern Rm_Result Rm_populatePermissionTable(const Rm_Resource *rmResourceTable);
-extern void Rm_updatePermissionTable(void);
-extern Rm_Result Rm_getInitPermissions (Rm_Perms *resourcePermissions);
-extern Rm_Result Rm_getUsePermissions (Rm_Perms *resourcePermissions);
-
-/* Permission checker handlers */
-extern Rm_Result Rm_initPermissionChecker (Rm_ResourceInfo *resourceData);
-extern Rm_Result Rm_usePermissionChecker (Rm_ResourceInfo *resourceData);
 
 #ifdef __cplusplus
 }
diff --git a/rm.h b/rm.h
index 771bd7bcbb6cefaabfc924158da4be102bacb560..4f59095d17ad16d49e458077a66da921c863bece 100644 (file)
--- a/rm.h
+++ b/rm.h
@@ -2,7 +2,7 @@
  *   @file  rm.h
  *
  *   @brief   
- *      This is the RM LLD include file.
+ *      This is the Resource Manager include file.
  *
  *  \par
  *  ============================================================================
 extern "C" {
 #endif
 
-/* RM resource table defs include file */
+/* RM version */
 #include <ti/drv/rm/rmver.h>
-#include <ti/drv/rm/rm_public_lld.h>
-#include <ti/drv/rm/resource_table_defs.h>
+/* RM component services include */
+#include <ti/drv/rm/rm_services.h>
+/* RM transport include */
+#include <ti/drv/rm/rm_transport.h>
+/* RM policy include */
+#include <ti/drv/rm/rm_policy.h>
 
-/**  @mainpage Resource Manager Low Level Driver
+/**  @mainpage Resource Manager
  *
  *   @section intro  Introduction
  *
@@ -127,34 +131,19 @@ extern "C" {
 /** @} */
 
 /**
-@defgroup RM_LLD_SYMBOL  RM Low Level Driver Symbols Defined
+@defgroup RM_TRANSPORT_API  RM Transport-Layer API
 @ingroup RM_LLD_API
 */
 /**
-@defgroup RM_LLD_ENUM  RM Low Level Driver Enums
+@defgroup RM_SERVICES_API  RM Registered Component Services API
 @ingroup RM_LLD_API
 */
 /**
-@defgroup RM_LLD_RESOURCE_TABLE  RM LLD Resource Table Definition Symbols and Structures
-@ingroup RM_LLD_API
-*/
-/**
-@defgroup RM_LLD_SHARED_RESOURCES  RM LLD ARM and DSP Shared Resources
-@ingroup RM_LLD_API
-*/
-/**
-@defgroup RM_LLD_DATASTRUCT  RM Low Level Driver Data Structures
-@ingroup RM_LLD_API
-*/
-/**
-@defgroup RM_LLD_FUNCTION  RM Low Level Driver Functions
-@ingroup RM_LLD_API
-*/
-/**
-@defgroup RM_LLD_OSAL  RM Low Level Driver OSAL Functions
+@defgroup RM_POLICY_API  RM Policy modification API
 @ingroup RM_LLD_API
 */
 
+
 /**
 @addtogroup RM_LLD_SYMBOL
 @{
@@ -185,21 +174,288 @@ extern "C" {
 @{ 
 */
 
+
+/** 
+@} 
+*/
+
+/** 
+ * @brief Maximum number of characters in a RM instance name
+ */
+#define RM_INST_NAME_MAX_CHARS (16)
+
 /** 
- * @brief RM Handle for LLDs
+ * @brief RM Handle provided to application.  The RM Handle is used by the
+ *        application to distinquish between different RM instances running on
+ *        the same core.
  */
 typedef void *Rm_Handle;
 
+/**
+ * @brief RM Service Handle provided to components that want to use RM to
+ *        for management of their resources.
+ */
+typedef void *Rm_ServiceHandle; 
+
 /** 
-@} 
-*/
+ * @brief RM Instance types
+ */
+typedef enum {
+    /** RM Server */
+    Rm_instType_SERVER = 0,
+    /** RM Client Delegate */
+    Rm_instType_CLIENT_DELEGATE,
+    /** RM Client */
+    Rm_instType_CLIENT
+} Rm_InstType;
+
+/** 
+ * @brief RM transport registration configuration structure
+ */
+typedef struct {
+    /** Defines the remote RM instance's type */
+    Rm_InstType rmRemoteInstType;
+} Rm_TransCfg;
+
+/** 
+ * @brief RM transport verification return value
+ */
+typedef enum {
+    /** RM transport paths verified as working. */
+    Rm_transVerify_VERIFIED = 0,
+    /** RM transport path verification error.  See Rm_TransFailData structure
+     *  for more information */
+    Rm_transVerify_ERROR
+} Rm_TransVerifyResult;
+
+/** 
+ * @brief If the RM transport path verification tests fail this structure
+ *        will be returned with specifics as to the error
+ */
+typedef struct {
+    /** Failing RM Instance Handle */
+    Rm_Handle failingRmHandle;
+    /** Failing transport handle */
+    Rm_TransHandle failingTransHandle;
+    /** If applicable: error codes received from failing transport */
+    uint32_t transErrorCode;
+} Rm_TransFailData;
+
+/** 
+ * @brief RM pre-main allocation request information provided by the pre-main 
+ *        startup function requesting the resource */
+typedef struct {
+    /** Pointer to the requested pre-main allocation resource name.  The 
+     *  name provided by the component must match the resource names
+     *  provided in the global resource table and allocation policies */
+    char *resourceName;
+    /** The pre-main allocation request resource index.  Typically this is the 
+     *  resource value.  For example, queue number or semaphore number */
+    uint32_t resourceIndex;
+} Rm_PreMainAllocInfo;
+
+/** 
+ * @brief RM instance initialization structure
+ */
+typedef struct {
+    /** Pointer to RM instance name character array.  The name of the RM instance must
+     *  be reflected exactly in the initial RM policies provided to the RM
+     *  tree's Servers and Client Delegates.  The RM instance name is
+     *  used by the policy to map which instances are allowed defined 
+     *  privileges */
+    char *instName;
+    /** RM instance type.  Defines whether the RM instance will be initialized
+     *  as a RM Server, Client Delegate, or Client */
+    Rm_InstType instType;
+    /** [Server Parameter] Pointer to the device-wide resource list.  The list
+     *  contains all resources available on the device available for 
+     *  allocation.  Servers running on ARM-Linux cores provide a subset
+     *  of the global device list for allocation.  The subset is formed from
+     *  the global resources leftover after the Linux DTB is parsed for 
+     *  resources reserved by Linux.  
+     *  
+     *  Note: This parameter will be ignored when the instance type is either 
+     *  Client Delegate or Client */
+    void *globalResourceList;
+    /** [Server/Client Delegate Paramter] Pointer to the startup allocation
+     *  policy.  RM Servers should be initialized with the global policy 
+     *  listing for all RM instances within the system.  RM Client Delegates 
+     *  can be initialized with their local policy, must be a subset of the 
+     *  global policy provided to the Client Delegate's Server.
+     *
+     *  Note: The core charged with the task of initializing the BIOS and IPC
+     *        components must run an RM Client Delegate with an initial policy
+     *        that allocates a system timer to BIOS and a HW semaphore to IPC
+     *  
+     *  Note: This parameter will be ignored when the instance type is a 
+     *        Client 
+     */
+    void *startupPolicy;
+    /** Pointer to application implemented rmAllocPkt API.  The API for the
+     *  provided function must match the rmAllocPkt function pointer API
+     * described in rm.h */
+    void *rmAllocPktFuncPtr;
+    /** Pointer to application implemented rmFreePkt API.  The API for the
+     *  provided function must match the rmFreePkt function pointer API
+     * described in rm.h */
+    void *rmFreePktFuncPtr;
+    /** Pointer to application implemented rmSend API.  The API for the
+     *  provided function must match the rmSend function pointer API
+     * described in rm.h */
+    void *rmSendFuncPtr;
+    /** Pointer to application implemented rmReceive API.  The API for the
+     *  provided function must match the rmReceive function pointer API
+     * described in rm.h */
+    void *rmReceiveFuncPtr;
+    /** Pointer to application implemented rmNumPktsReceived API.  The API for 
+     *  the provided function must match the rmNumPktsReceived function 
+     *  pointer API described in rm.h */
+    void *rmNumPktsReceivedFuncPtr;
+} Rm_InitCfg;
 
-/* Exported functions available to application */
-extern Rm_Result Rm_init (const Rm_Resource *rmResourceTable);
-extern Rm_Result Rm_start (void);
-extern Rm_Handle Rm_getHandle(void);
-extern uint32_t Rm_getVersion (void);
-extern const char* Rm_getVersionStr (void);
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function initializes a RM instance.
+ * 
+ *      IMPORTANT: Rm_init must be called prior to any other component startup
+ *                 APIs (BIOS_start, Ipc_start, etc).
+ *
+ *  @param[in]  *initCfg
+ *      Pointer to structure containing the initialization information for
+ *      this RM instance.
+ *
+ *  @retval
+ *      Success - non-zero Rm_Handle returned.
+ *  @retval
+ *      Failure - NULL Rm_handle returned.
+ */
+Rm_Handle Rm_init(Rm_InitCfg *initCfg);
+
+/**
+ *  @b Description
+ *  @n  
+ *      Non-blocking function used by RTSC pre-main startup functions to
+ *      allocate RM resources for usage.  Pre-main allocated resources will be 
+ *      validated by RM against a memory-mapped startup resource policy.
+ *      Pre-main allocation of unauthorized resources will result in a system
+ *      exception.
+ *
+ *      Note: Resource pre-main allocations can only occur on a core that is 
+ *            running a RM Server or Client Delegate that has a startup policy
+ *            allowing the allocation of pre-main resources
+ *
+ *  @param[in]  preMainAllocInfo
+ *      Resource pre-main allocation structure that provides details of the 
+ *      resource requested from RM for preallocation
+ *
+ *  @retval
+ *      Success - 0 - Resource pre-main allocation request okay.
+ *  @retval
+ *      Failure - non-zero - Resource pre-main allocation request error.
+ */
+Rm_Result Rm_preMainAllocResource(Rm_PreMainAllocInfo 
+                                                   *preMainAllocInfo);
+
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function returns a RM service handle to the application to 
+ *      provide to software components (LLDs, BIOS, etc) that want to use RM.
+ *
+ *  @param[in]  rmHandle
+ *      RM instance handle.  Used to return a ServiceHandle from the proper
+ *      RM instance in cases where there are multiple RM instances running on 
+ *      a single core.
+ *
+ *  @retval
+ *      Success - RM Service Handle.  Used as an input parameter for 
+ *                component startCfg functions.
+ *  @retval
+ *      Failure - NULL
+ */
+Rm_ServiceHandle Rm_getServiceHandle(Rm_Handle rmHandle);
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function is used to register transports with RM for sending and
+ *      receiving packets between RM instances over application transport
+ *      data paths.
+ *
+ *  @param[in]  rmHandle
+ *      RM instance to which the transport will be registered.  Used internally
+ *      by RM if there are more than one RM instances per core.
+ *
+ *  @param[in]  transCfg
+ *      Transport registration configuration structure.  Provides information
+ *      regarding the application transports remote entity.  For example,
+ *      if the transCfg structure specifies the remote type is the RM Server
+ *      RM will know any Server requests must be pushed to the application
+ *      transport API with the transport handle returned to the application
+ *
+ *  @retval
+ *      Success - non-NULL RM transport handle.  No two transport handles
+ *                returned by RM should be the same.
+ *  @retval
+ *      Failure - NULL
+ */
+Rm_TransHandle Rm_registerTransport (Rm_Handle rmHandle, 
+                                     Rm_TransCfg *transCfg);
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function places the selected RM instance into the transport
+ *      verification state.  When all RM instances in the tree are placed
+ *      in the transport verification state a transport path verification
+ *      test will take place to verify the application transport paths between
+ *      all RM tree nodes are connected correctly.
+ *
+ *      Note: This API should not be called until all transport have been
+ *            registered with RM
+ *
+ *  @param[in]  rmHandle
+ *      Which RM instance to begin the transport verification process
+ *
+ *  @param[in]  timeout
+ *      Number of ______ (cycles, usec, msec???) to wait before signaling a
+ *      transport path verification timeout
+ *
+ *  @param[in]  failData
+ *      Pointer to an empty Rm_TransFailData structure.  If the transport
+ *      verification process fails this structure will return with transport
+ *      failure data
+ *
+ *  @retval
+ *      Success - 0 - Transport Verification succeeded
+ *  @retval
+ *      Failure - non-0 - Transport Verification failed
+ */
+Rm_TransVerifyResult Rm_verifyTransport (Rm_Handle, uint32_t timeout, 
+                                         Rm_TransFailData *failData);
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to get the version information of the RM.
+ *
+ *  @retval
+ *      Version Information.
+ */
+uint32_t Rm_getVersion (void);
+
+/**
+ *  @b Description
+ *  @n  
+ *      The function is used to get the version string for the RM.
+ *
+ *  @retval
+ *      Version String.
+ */
+const char* Rm_getVersionStr (void);
 
 #ifdef __cplusplus
 }
index c41032ddfbd193fc67dab039c28e98f667fd1f20..63e0f7e615b6c58a9ffd69e1d1f09ec4a8f85dc3 100644 (file)
--- a/rm_osal.h
+++ b/rm_osal.h
  */
 #include <string.h>
 
-extern void* Osal_rmMalloc (uint32_t num_bytes);
-extern void Osal_rmFree (void *ptr, uint32_t size);
+extern void* Osal_rmMalloc (uint32_t num_bytes, bool shared);
+extern void Osal_rmFree (void *ptr, uint32_t size, bool shared);
+extern void* Osal_rmLocalCsEnter (void);
+extern void Osal_rmLocalCsExit (void *CsHandle);
 extern void* Osal_rmCsEnter (void);
 extern void Osal_rmCsExit (void *CsHandle);
 extern void* Osal_rmMtCsEnter (void);
@@ -104,6 +106,9 @@ extern void Osal_rmEndMemAccess (void *ptr, uint32_t size);
  *  <b> Parameter </b>
  *  @n  Number of bytes to be allocated
  *
+ *  <b> Parameter </b>
+ *  @n  If true the memory should could from shared memory
+ *
  *  <b> Return Value </b>
  *  @n  Pointer to the allocated block size
  */
@@ -131,6 +136,45 @@ extern void Osal_rmEndMemAccess (void *ptr, uint32_t size);
 
 #define Rm_osalFree               Osal_rmFree
 
+/**
+ * @brief   The macro is used by the RM LLD to provide critical sections to 
+ *    protect shared variables from access from multiple RM instances
+ *    on a single core
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void* Osal_rmLocalCsEnter (void)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  None.
+ *
+ *  <b> Return Value </b>
+ *  @n  Handle used to lock critical section.
+ */
+#define Rm_osalLocalCsEnter            Osal_rmLocalCsEnter
+
+/**
+ * @brief   The macro is used by the RM LLD to exit a critical section 
+ *      protected using Osal_rmLocalCsEnter() API.
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void Osal_rmLocalCsExit (void *CsHandle)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  Handle for unlocking critical section.
+ *
+ *  <b> Return Value </b>
+ *  @n  Not applicable.
+ */
+#define Rm_osalLocalCsExit             Osal_rmLocalCsExit
+
 /**
  * @brief   The macro is used by the RM LLD to provide critical sections to 
  * protect global and shared variables from
diff --git a/rm_policy.h b/rm_policy.h
new file mode 100644 (file)
index 0000000..c95d667
--- /dev/null
@@ -0,0 +1,148 @@
+/**
+ *   @file  rm_policy.h
+ *
+ *   @brief   
+ *      This is the RM include file for the policy APIs
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2012, 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
+*/
+
+#ifndef RM_POLICY_H_
+#define RM_POLICY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@addtogroup RM_POLICY_API
+@{
+*/
+/**
+ * @brief Maximum number of characters in the policy name
+ */
+#define RM_MAX_POLICY_NAME_LENGTH 8
+
+/**
+ * @brief Policy handle
+ */
+typedef uint32_t *Rm_PolicyHandle;
+
+/** 
+ * @brief Result of RM policy operations
+ */
+typedef int32_t   Rm_PolicyResult;
+
+/**
+ * @brief Structure populated by policy API with basic RM policy information
+ */
+typedef struct {
+    /** Policy name */
+    char policyName[RM_MAX_POLICY_NAME_LENGTH] ;
+    /** Policy handle */
+    Rm_PolicyHandle policyHandle;
+} Rm_PolicyInfo;
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function returns the number of policies located within a RM
+ *      instance tree
+ *
+ *  @param[in]  serverHandle
+ *      RM tree's server handle.  Used to report the number of policies for
+ *      the given server handle's instance tree
+ *
+ *  @retval
+ *      Number of policies located within the instance tree
+ */
+uint32_t Rm_numPoliciesInTree(Rm_Handle serverHandle);
+
+/**
+ *  @b Description
+ *  @n  
+ *      This function returns a list of all policies within the system.  The
+ *      list will contain a policy name and handle for each policy.
+ *
+ *  @param[in]  serverHandle
+ *      RM tree's server handle.  Used to query the policy information for
+ *      the given server handle's instance tree
+ *
+ *  @param[in]  *policyInfoArray
+ *      An array of Rm_PolicyInfo structures that will contain information for
+ *      all policies within the instance tree upon function return.
+ *
+ *      Note: The size of the array passed must be equal to or greater than 
+ *            the number of policies returned by the Rm_numPoliciesInTree API
+ *
+ *  @retval
+ *      SUCCESS - 0
+ *  @retval
+ *      FAILURE - non-zero value
+ */
+Rm_PolicyResult Rm_listPolicies(Rm_Handle serverHandle, Rm_PolicyInfo *policyInfoArray);
+
+The following API input parameters are not finalized yet as they are a wrapper around the DTB modification APIs provided in the dtc library.  The input parameters will be finalized as the operation of the dtc API is better understood.
+
+/* Policy create/delete APIs */
+
+/* May not allow additional input parameters.  Created policies can be
+ * modified using the policy modification APIs */
+Rm_PolicyHandle Rm_createPolicy(Rm_Handle serverHandle, ...);
+Rm_PolicyResult Rm_deletePolicy(Rm_PolicyHandle);
+
+/* Policy modification APIs */
+Rm_PolicyResult Rm_addInstToPolicy(Rm_PolicyHandle, ...);
+Rm_PolicyResult Rm_deleteInstFromPolicy(Rm_PolicyHandle, ...);
+Rm_PolicyResult Rm_addResourceToPolicy(Rm_PolicyHandle, instName, ...);
+Rm_PolicyResult Rm_deleteResourceFromPolicy(Rm_PolicyHandle, instName, ...);
+Rm_PolicyResult Rm_modifyResourceProp(Rm_PolicyHandle, instName, resName ...);
+
+/* Read Policy APIs */
+Rm_PolicyResult Rm_listPolicyInstances(Rm_PolicyHandle, ...);
+Rm_PolicyResult Rm_listInstResources(Rm_PolicyHandle, instName, ...);
+Rm_PolicyResult Rm_listPolicyResourceProperties(Rm_PolicyHandle, instName, 
+                                                resourceName, ...);
+
+
+/** 
+@} 
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RM_POLICY_H_ */
diff --git a/rm_public.h b/rm_public.h
deleted file mode 100644 (file)
index 511ac5a..0000000
+++ /dev/null
@@ -1,198 +0,0 @@
-/**
- *   @file  rm_public_lld.h
- *
- *   @brief   
- *      This is the RM LLD include file for other LLDs.
- *
- *  \par
- *  ============================================================================
- *  @n   (C) Copyright 2012, 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
-*/
-
-#ifndef RM_PUBLIC_LLD_H_
-#define RM_PUBLIC_LLD_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* QMSS type include */
-#include <ti/drv/qmss/qmss_qm.h>
-
-/* CPPI type include */
-#include <ti/csl/csl_cppi.h>
-
-/**
-@addtogroup RM_LLD_SYMBOL
-@{
-*/
-
-/** RM Permission Return And Error Codes */
-/** RM LLD Permission Approved Base */
-#define RM_APPROVED_BASE 0
-/** Resource initialization permission approved */
-#define RM_INIT_PERMISSION_APPROVED  (RM_APPROVED_BASE+1)
-/** Resource usage permission approved */
-#define RM_USE_PERMISSION_APPROVED  (RM_APPROVED_BASE+2)
-
-/** RM LLD Permission Denied Base */
-#define RM_DENIED_BASE (-64)
-/** Resource initialization permission denied */
-#define RM_INIT_PERMISSION_DENIED  (RM_DENIED_BASE-1)
-/** Resource usage permission denied */
-#define RM_USE_PERMISSION_DENIED  (RM_DENIED_BASE-2)
-
-/**
-@}
-*/
-
-/**
-@addtogroup RM_LLD_ENUM
-@{
-*/
-
-/** 
- * @brief LLD resource type
- */
-typedef enum
-{
-    /** QMSS Firmware Type */
-    Rm_resource_QMSS_FIRMWARE_PDSP = 0,
-    /** QMSS Queue Type */
-    Rm_resource_QMSS_QUEUE,
-    /** QMSS Memory Region Type */
-    Rm_resource_QMSS_MEMORY_REGION,
-    /** QMSS Linking RAM Control Type */
-    Rm_resource_QMSS_LINKING_RAM_CONTROL,
-    /** QMSS Linking RAM Type */
-    Rm_resource_QMSS_LINKING_RAM,
-    /** QMSS Accumulator Channel Type */
-    Rm_resource_QMSS_ACCUM_CH,
-    /** QMSS QOS PDSP Timer */
-    Rm_resource_QMSS_QOS_TIMER,
-    /** QMSS QOS Cluster Type */
-    Rm_resource_QMSS_QOS_CLUSTER,
-    /** QMSS QOS Queue Type */
-    Rm_resource_QMSS_QOS_QUEUE,
-    /** CPPI Transmit Channel Type */
-    Rm_resource_CPPI_TX_CH,
-    /** CPPI Receive Channel Type */
-    Rm_resource_CPPI_RX_CH,
-    /** CPPI Receive Flow Type */
-    Rm_resource_CPPI_RX_FLOW,
-    /** PA Firmware Type */
-    Rm_resource_PA_FIRMWARE,
-    /** PA LUT Type */
-    Rm_resource_PA_LUT
-}Rm_ResourceType;
-
-/**
-@}
-*/
-
-/** @addtogroup RM_LLD_DATASTRUCT
-@{ 
-*/
-
-/** 
- * @brief Structure specifying the Linking RAM start and end indices
- */
-typedef struct
-{
-    uint32_t linkRamStartIndex;
-    uint32_t linkRamEndIndex;
-} Rm_ResourceLinkRamInfo;
-
-/** 
- * @brief Structure specifying the CPPI rx channel, tx channel, and flow ID information
- */
-typedef struct
-{
-    Cppi_CpDma dmaNum;
-    int32_t cppiChNumOrFlowId;
-} Rm_ResourceCpDmaInfo;
-
-/** 
- * @brief Structure specifying the LLD resource to have permissions checked by RM
- */
-typedef struct
-{
-    /** LLD resource type to be checked */
-    Rm_ResourceType resourceType;
-    
-    /** Resource parameters union. */
-    union
-    {
-        /** QMSS Resource Data */
-        uint16_t pdspNum;
-        int queNum;
-        Qmss_MemRegion memRegion;
-        Rm_ResourceLinkRamInfo linkRamData;
-        uint8_t accumCh;
-        uint32_t qosCluster;
-        uint32_t qosQueue;        
-
-        /** CPPI Resource Data */
-        Rm_ResourceCpDmaInfo cpDmaData;
-
-        /** PA Resource Data */
-        int32_t lutEntry;
-    } res_info;
-} Rm_ResourceInfo;
-
-/** 
- * @brief RM return result
- */
-typedef int32_t   Rm_Result;
-
-/** 
- * @brief Structure of LLD function callouts for permissions checks
- */
-typedef struct
-{
-    /** Init permissions check function */
-    Rm_Result  (*rmInitPermissionsCheck)(Rm_ResourceInfo *resourceData);
-    /** Use permissions check function */
-    Rm_Result  (*rmUsePermissionsCheck)(Rm_ResourceInfo *resourceData); 
-}Rm_LldPermCallouts;
-
-/** 
-@} 
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* RM_PUBLIC_LLD_H_ */
-
diff --git a/rm_services.h b/rm_services.h
new file mode 100644 (file)
index 0000000..c4b9157
--- /dev/null
@@ -0,0 +1,183 @@
+/**
+ *   @file  rm_services.h
+ *
+ *   @brief   
+ *      This is the RM include file for services provided to components that register a RM 
+ *      instance
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2012, 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
+*/
+
+#ifndef RM_SERVICES_H_
+#define RM_SERVICES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@addtogroup RM_SERVICES_API
+@{
+*/
+
+/** 
+ * @brief RM will return the next available resource if the component assigns 
+ *        "not specified" in the resourceIndex field when the resource allocate
+ *        service is initiated.        
+ */
+#define RM_SERVICE_INDEX_NOT_SPECIFIED (-1)
+
+/** 
+ * @brief Result of requested RM service
+ */
+typedef enum {
+    /** RM Service was okay */
+    RM_service_OKAY = 0,
+    /** RM Service request not recognized */
+    RM_service_INVALID_SERVICE_TYPE = 1
+} Rm_ServiceResult;
+
+/** 
+ * @brief RM service types
+ */
+typedef enum {
+    /** RM resource allocate service */
+    Rm_service_RESOURCE_ALLOCATE = 0,
+    /** RM resource block allocate service */
+    Rm_service_RESOURCE_BLOCK_ALLOCATE,
+    /** RM resource allocate by name service */
+    Rm_service_RESOURCE_ALLOCATE_BY_NAME,    
+    /** RM resource free service */
+    Rm_service_RESOURCE_FREE,
+    /** RM resource block free service */
+    Rm_service_RESOURCE_BLOCK_FREE,
+    /** RM resource free by name service */
+    Rm_service_RESOURCE_FREE_BY_NAME,
+    /** RM resource mapping to name service */
+    Rm_service_RESOURCE_MAP_TO_NAME,
+    /** RM resource name unmapping service */
+    Rm_service_RESOURCE_UNMAP_NAME,
+    /** RM resource status service */
+    Rm_service_RESOURCE_STATUS
+} Rm_ServiceType;
+
+/** 
+ * @brief RM service response information provided by RM back to the requesting component
+ */
+typedef struct {
+    /** A request ID will be returned to the component if the requested service cannot
+     * be completed immediately.  The request ID can be used by the component to identify
+     * service responses received via the component callback function.  A request ID will not
+     * be returned if the service request is satisfied immediately */
+    uint32_t requestId;
+    /** The value of the returned resource.  In the case of a block resource allocation response
+     * this field will contain the base value of the block. */
+    int32_t resBase;
+    /** The number of resources allocated in block requests */
+    uint32_t resNum;
+} Rm_ServiceRespInfo;
+
+/** 
+ * @brief RM service request information provided by the requesting component
+ */
+typedef struct {
+    /** The type of RM service requested */
+    Rm_ServiceType serviceType;
+    /** Pointer to the name of the resource requested.  The 
+     *  name provided by the component must match the resource node names
+     *  provided in the global resource table and allocation policies */
+    char *resName;
+    /** The resource base value. */
+    int32_t resBase;
+    /** The number of the specified resources.  Will be greater than one only
+     * for block allocate and free service requests. */
+    uint32_t resNum;
+    /** Resource alignment in block allocation requests */
+    uint32_t resAlign;    
+    /** The name server name associated with the resource.  Used only for 
+     * allocate and free by name service requests */
+    char *resNsName;
+    /** Component callback function.  RM will call this function when the 
+     *  resource service request is completed. The callback function supplied
+     *  for this parameter must match this function pointer prototype. */
+    void (*serviceCallback) (Rm_ServiceResult rmResult, char *resourceName,
+                             uint32_t resourceIndex);
+} Rm_ServiceReqInfo;
+
+
+/** 
+ * @brief RM Service Handle provided to software components that 
+ *        request RM services for the resources they control
+ */
+typedef struct {
+    /** RM instance handle for which the service handle was registered */
+    void *rmHandle;
+    /**
+     *  @b Description
+     *  @n  
+     *      Callout function used by components to request a resource service 
+     *      from a RM instance
+     *
+     *   @param[in] rmHandle
+     *      RM instance handle specifying the RM instance that should handle the
+     *      service request
+     *  
+     *  @param[in]  requestInfo
+     *      Service request structure that provides details of the service requested from
+     *      the RM instance tied to this component
+     *
+     *  @param[in]  responseInfo
+     *      Service response structure that provides details of RM's response to the
+     *      service request
+     *
+     *  @retval
+     *      Success - 0 - Service request was handled okay.
+     *  @retval
+     *      Failure - non-zero - Service request error.
+     */
+    Rm_ServiceResult  (*rmService)(void *rmHandle, Rm_ServiceReqInfo *requestInfo,
+                                                      Rm_ServiceRespInfo *responseInfo);
+} Rm_ServicesPort;
+
+/** 
+@} 
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RM_SERVICES_H_ */
+
diff --git a/rm_transport.h b/rm_transport.h
new file mode 100644 (file)
index 0000000..32acc35
--- /dev/null
@@ -0,0 +1,225 @@
+/**
+ *   @file  rm_transport.h
+ *
+ *   @brief   
+ *      This is the RM include file for the generic transport interface used by RM to exchange
+ *      RM control signals and data between RM instances
+ *
+ *  \par
+ *  ============================================================================
+ *  @n   (C) Copyright 2012, 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
+*/
+
+#ifndef RM_TRANSPORT_H_
+#define RM_TRANSPORT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@addtogroup RM_TRANSPORT_API
+@{
+*/
+
+/** Maximum size of the RM transport packet */
+#define RM_TRANSPORT_PACKET_MAX_SIZE_BYTES (128)  // Placeholder: This will 
+                                                 // change during development
+
+/** 
+ * @brief RM transport handle
+ */
+typedef void *Rm_TransportHandle;
+
+/** 
+ * @brief Result of RM transport layer operations
+ */
+typedef int32_t   Rm_TransportResult;
+
+/** 
+ * @brief RM transport layer packet packet descriptor structure
+ */
+typedef struct {
+    /** Length of packet.  Written by application when allocated */
+    uint32_t rmPktLen;
+    /** Pointer to RM resource packet */
+    char rmData[RM_TRANSPORT_PACKET_MAX_SIZE_BYTES];
+} Rm_Packet;
+
+
+typedef struct {
+    /**
+     *  @b Description
+     *  @n  
+     *      This function pointer describes the RM transport layer packet 
+     *      allocation function.  The application which integrates with RM must 
+     *      supply a function to RM at initialization time that matches this  
+     *      prototype.  The provided function implements the allocation of packet
+     *      buffers for use by the RM transport for sending messages between RM
+     *      instances in the SOC.
+     *
+     *  @param[in]  transHandle
+     *      Which application transport to allocate a packet from.
+     *
+     *  @param[in]  pktSize
+     *      Size of requested packet allocation.
+     *
+     *  @retval
+     *      Success - Pointer to allocated packet buffer.
+     *  @retval
+     *      Failure - NULL
+     */
+    Rm_Packet *(*rmAllocPkt)(Rm_TransHandle transHandle, uint32_t pktSize);
+    
+    /**
+     *  @b Description
+     *  @n  
+     *      This function pointer describes the RM transport layer packet 
+     *      free function.  The application which integrates with RM must 
+     *      supply a function to RM at initialization time that matches this  
+     *      prototype.  The provided function implements the free of packet
+     *      buffers used by the RM transport for sending/receiving messages 
+     *      between RM instances in the SOC.
+     *
+     *  @param[in]  transHandle
+     *      Which application transport to free the packet to.
+     *
+     *  @param[in]  pkt
+     *      Pointer to resource packet to be freed.
+     *
+     *  @retval
+     *      0 - Packet free okay.
+     *  @retval
+     *      Non-zero - Send failed.
+     */
+    Rm_TransportResult  (*rmFreePkt)(Rm_TransHandle transHandle, Rm_Packet *pkt);
+    
+    /**
+     *  @b Description
+     *  @n  
+     *      This function pointer describes the RM transport layer send function.
+     *      The application which integrates with RM must supply a function to RM
+     *      at initialization time that matches this prototype.  The provided 
+     *      function implements the send side of the transport between RM 
+     *      instances on different cores in the SOC.
+     *
+     *  @param[in]  transHandle
+     *      Which application transport to send the packet over.
+     *
+     *  @param[in]  pkt
+     *      Pointer to resource packet to be sent to the destination RM.
+     *
+     *  @retval
+     *      0 - Packet sent okay.
+     *  @retval
+     *      Non-zero - Send failed.
+     */
+    Rm_TransportResult  (*rmSend)(Rm_TransHandle transHandle, Rm_Packet *pkt);
+    
+    /**
+     *  @b Description
+     *  @n  
+     *      This function pointer describes the RM transport layer receive 
+     *      function. The application which integrates with RM must supply a 
+     *      function to RM at initialization time that matches this prototype.
+     *      The provided function implements the receive side of the transport 
+     *      between RM instances on different cores in the SOC.
+     *
+     *  @param[in]  transHandle
+     *      Which application transport to retrieve a packet from
+     *
+     *  @param[in]  pkt
+     *      Pointer to received resource packet.
+     *
+     *  @retval
+     *      0 - Packet reception okay.
+     *  @retval
+     *      Non-zero - Packet receive failed.
+     */
+    Rm_TransportResult  (*rmReceive)(Rm_TransHandle transHandle, Rm_Packet *pkt);
+    
+    /**
+     *  @b Description
+     *  @n  
+     *      This function pointer describes the RM transport layer number of
+     *      packets received function. The application which integrates with RM 
+     *      must supply a function to RM at initialization time that matches this 
+     *      prototype.  The provided function implements a query of the number of
+     *      RM packets received on a specified transport.
+     *
+     *  @param[in]  transHandle
+     *      Which application transport to check for received packets.
+     *
+     *  @retval
+     *      Success -   Number of packets received over transport interfaces for
+     *                  a RM instance.
+     *  @retval
+     *      Failure -   -1
+     */
+    int32_t (*rmNumPktsReceived)(Rm_TransHandle transHandle);
+} Rm_TransportCallouts;
+
+/**
+ *  @b Description
+ *  @n  
+ *      This is the RM transport layer function available for application
+ *      transport code callbacks.  This API can be called if the application
+ *      transport wants to report a received RM packet to the RM instance.
+ *      This API can be used if RM polling the application code for received
+ *      packets is not desired.
+ *
+ *  @param[in]  transHandle
+ *      Transport handle.  Used to distinguish which RM instance the packet
+ *      was received from and how to internally route the packet if more than
+ *      one RM instance exists on the core.
+ *
+ *  @param[in]  pkt
+ *      Pointer to received resource packet.
+ *
+ *  @retval
+ *      Success - 0
+ *  @retval
+ *      Failure - Non-zero RM error
+ */
+Rm_Result rmTransportCallback(Rm_TransHandle transHandle, Rm_Packet *pkt);
+
+
+/** 
+@} 
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RM_TRANSPORT_H_ */
diff --git a/rm_types.h b/rm_types.h
new file mode 100644 (file)
index 0000000..643be40
--- /dev/null
@@ -0,0 +1,53 @@
+/**
+ *   @file  rm_types.h
+ *
+ *   @brief   
+ *      This is a wrapper header file which includes the standard types
+ *      used by the RM.
+ *
+ *  \par
+ *  NOTE:
+ *      (C) Copyright 2012 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
+*/
+#ifndef __RM_TYPES_H__
+#define __RM_TYPES_H__
+
+/* c99 include */
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#endif /* __RM_TYPES_H__ */
+
+
+
index caf68b25c57bf07263df9dd4608b85841b53c7f5..5ec0c98f09564d514cfcb1b63956f4010e5eb1e3 100644 (file)
@@ -26,7 +26,7 @@
       }\r
   }\r
   \r
-  var versionStr = "\""+"RM LLD Revision: "+ver1[0]+"."+ver1[1]+"."+ver1[2]+"."+ver1[3]+"\"";\r
+  var versionStr = "\""+"RM Revision: "+ver1[0]+"."+ver1[1]+"."+ver1[2]+"."+ver1[3]+"\"";\r
   var versionID = "(0x"+ver2[0]+ver2[1]+ver2[2]+ver2[3]+")";\r
 \r
 %%}\r
@@ -43,7 +43,7 @@ extern "C" {
  *\r
  *   path  ti/drv/rm/rmver.h\r
  *\r
- *   @brief  Resource Manager LLD Version Definitions\r
+ *   @brief  Resource Manager Version Definitions\r
  *\r
  *  ============================================================\r
  *  Copyright (c) Texas Instruments Incorporated 2009-2012\r
@@ -79,17 +79,17 @@ extern "C" {
 */\r
 \r
 /**\r
- * @brief   This is the RM LLD Version. Versions numbers are encoded in the following \r
+ * @brief   This is the RM Version. Versions numbers are encoded in the following \r
  * format:\r
  *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)\r
  */\r
-#define RM_LLD_VERSION_ID                   `versionID`\r
+#define RM_VERSION_ID                   `versionID`\r
 \r
 /**\r
- * @brief   This is the version string which describes the RM LLD along with the\r
+ * @brief   This is the version string which describes the RM along with the\r
  * date and build information.\r
  */\r
-#define RM_LLD_VERSION_STR                  `versionStr`\r
+#define RM_VERSION_STR                  `versionStr`\r
 \r
 \r
 #ifdef __cplusplus\r
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;
 }
 
 /**