Started adding Shared Server implementation
authorJustin Sobota <jsobota@ti.com>
Thu, 14 Mar 2013 21:50:40 +0000 (17:50 -0400)
committerJustin Sobota <jsobota@ti.com>
Thu, 14 Mar 2013 21:50:40 +0000 (17:50 -0400)
26 files changed:
device/k2h/policy_dsp-only.c
device/k2h/policy_dsp-only.dtb
device/k2h/policy_dsp-only.dts
device/k2h/policy_dsp_arm.c
device/k2h/policy_dsp_arm.dtb
device/k2h/policy_dsp_arm.dts
device/k2k/policy_dsp-only.c
device/k2k/policy_dsp-only.dtb
device/k2k/policy_dsp-only.dts
device/k2k/policy_dsp_arm.c
device/k2k/policy_dsp_arm.dtb
device/k2k/policy_dsp_arm.dts
include/rm_internal.h
include/rm_nameserverloc.h
include/rm_treeloc.h
rm.h
rm_osal.h
src/rm.c
src/rm_allocator.c
src/rm_nameserver.c
src/rm_services.c
src/rm_transport.c
src/rm_tree.c
test/rm_osal.c
test/rm_test.c
util/tree.h

index d05570bd689588a5d21d83dbf80674520057f198..f7ae7f4dab9ebc86fd33569266c0c0b526b6ee44 100644 (file)
@@ -5,16 +5,16 @@ const char rmDspOnlyPolicy[] = {
 0xed,
 0x00,
 0x00,
-0x0a,
-0xe4,
+0x0b,
+0x20,
 0x00,
 0x00,
 0x00,
 0x38,
 0x00,
 0x00,
-0x0a,
-0xc8,
+0x0b,
+0x04,
 0x00,
 0x00,
 0x00,
@@ -38,7 +38,7 @@ const char rmDspOnlyPolicy[] = {
 0x00,
 0x00,
 0x0a,
-0x90,
+0xcc,
 0x00,
 0x00,
 0x00,
@@ -70,7 +70,7 @@ const char rmDspOnlyPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x27,
+0x62,
 0x00,
 0x00,
 0x00,
@@ -94,15 +94,73 @@ const char rmDspOnlyPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x30,
+0x00,
+0x52,
+0x4d,
 0x5f,
-0x44,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x31,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
 0x6c,
+0x69,
 0x65,
-0x67,
-0x61,
+0x6e,
 0x74,
+0x32,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x33,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x34,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x35,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x36,
 0x00,
 0x52,
 0x4d,
@@ -113,6 +171,8 @@ const char rmDspOnlyPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x37,
+0x00,
 0x00,
 0x00,
 0x00,
index 7ff0dc33579f71246e288d5a9ed868b25b1067cc..d36b14e568ba2b294a528379e6c820596c0e1ac7 100644 (file)
Binary files a/device/k2h/policy_dsp-only.dtb and b/device/k2h/policy_dsp-only.dtb differ
index e09c5e2fcdaeccdfa8ab2a7dc63d352eb9029f54..90f242c38163c2615f62d4bad90abfbddb8d697d 100644 (file)
@@ -8,8 +8,14 @@
      * RM.  For an RM instance to be given permissions the name used to initialize it
      * must be present in this list */
     valid-instances = "RM_Server",
-                      "RM_Client_Delegate",
-                      "RM_Client";
+                      "RM_Client0",
+                      "RM_Client1",
+                      "RM_Client2",
+                      "RM_Client3",
+                      "RM_Client4",
+                      "RM_Client5",
+                      "RM_Client6",
+                      "RM_Client7";
        
     qmss {
         linkram-control {
index 3523c1bfd85e2fbbeafb1be4e70ca57bc2dc6efb..5783f58bf96a2b07cb84312a03f343932a679d8f 100644 (file)
@@ -6,7 +6,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x90,
+0xcc,
 0x00,
 0x00,
 0x00,
@@ -14,7 +14,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x74,
+0xb0,
 0x00,
 0x00,
 0x00,
@@ -38,7 +38,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x3c,
+0x78,
 0x00,
 0x00,
 0x00,
@@ -70,7 +70,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x27,
+0x62,
 0x00,
 0x00,
 0x00,
@@ -94,15 +94,40 @@ const char rmDspPlusArmPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x30,
+0x00,
+0x52,
+0x4d,
 0x5f,
-0x44,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x31,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
 0x6c,
+0x69,
 0x65,
-0x67,
-0x61,
+0x6e,
 0x74,
+0x32,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x33,
 0x00,
 0x52,
 0x4d,
@@ -113,6 +138,41 @@ const char rmDspPlusArmPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x34,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x35,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x36,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x37,
+0x00,
 0x00,
 0x00,
 0x00,
index a16d74d775d7c81570579ae4b6552b336e9ce1fe..98fdfe2cd7316443e0389858609bbe7ddca4333e 100644 (file)
Binary files a/device/k2h/policy_dsp_arm.dtb and b/device/k2h/policy_dsp_arm.dtb differ
index b071a3fb04a6f3272740e0d1477d0319369baaae..4eb3b64293150e812ce0009279d14cae9ab22130 100644 (file)
@@ -8,8 +8,14 @@
      * RM.  For an RM instance to be given permissions the name used to initialize it
      * must be present in this list */
     valid-instances = "RM_Server",
-                      "RM_Client_Delegate",
-                      "RM_Client";
+                      "RM_Client0",
+                      "RM_Client1",
+                      "RM_Client2",
+                      "RM_Client3",
+                      "RM_Client4",
+                      "RM_Client5",
+                      "RM_Client6",
+                      "RM_Client7";
        
     qmss {
         linkram-control {
index d05570bd689588a5d21d83dbf80674520057f198..f7ae7f4dab9ebc86fd33569266c0c0b526b6ee44 100644 (file)
@@ -5,16 +5,16 @@ const char rmDspOnlyPolicy[] = {
 0xed,
 0x00,
 0x00,
-0x0a,
-0xe4,
+0x0b,
+0x20,
 0x00,
 0x00,
 0x00,
 0x38,
 0x00,
 0x00,
-0x0a,
-0xc8,
+0x0b,
+0x04,
 0x00,
 0x00,
 0x00,
@@ -38,7 +38,7 @@ const char rmDspOnlyPolicy[] = {
 0x00,
 0x00,
 0x0a,
-0x90,
+0xcc,
 0x00,
 0x00,
 0x00,
@@ -70,7 +70,7 @@ const char rmDspOnlyPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x27,
+0x62,
 0x00,
 0x00,
 0x00,
@@ -94,15 +94,73 @@ const char rmDspOnlyPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x30,
+0x00,
+0x52,
+0x4d,
 0x5f,
-0x44,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x31,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
 0x6c,
+0x69,
 0x65,
-0x67,
-0x61,
+0x6e,
 0x74,
+0x32,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x33,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x34,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x35,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x36,
 0x00,
 0x52,
 0x4d,
@@ -113,6 +171,8 @@ const char rmDspOnlyPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x37,
+0x00,
 0x00,
 0x00,
 0x00,
index 7ff0dc33579f71246e288d5a9ed868b25b1067cc..d36b14e568ba2b294a528379e6c820596c0e1ac7 100644 (file)
Binary files a/device/k2k/policy_dsp-only.dtb and b/device/k2k/policy_dsp-only.dtb differ
index e09c5e2fcdaeccdfa8ab2a7dc63d352eb9029f54..90f242c38163c2615f62d4bad90abfbddb8d697d 100644 (file)
@@ -8,8 +8,14 @@
      * RM.  For an RM instance to be given permissions the name used to initialize it
      * must be present in this list */
     valid-instances = "RM_Server",
-                      "RM_Client_Delegate",
-                      "RM_Client";
+                      "RM_Client0",
+                      "RM_Client1",
+                      "RM_Client2",
+                      "RM_Client3",
+                      "RM_Client4",
+                      "RM_Client5",
+                      "RM_Client6",
+                      "RM_Client7";
        
     qmss {
         linkram-control {
index 3523c1bfd85e2fbbeafb1be4e70ca57bc2dc6efb..5783f58bf96a2b07cb84312a03f343932a679d8f 100644 (file)
@@ -6,7 +6,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x90,
+0xcc,
 0x00,
 0x00,
 0x00,
@@ -14,7 +14,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x74,
+0xb0,
 0x00,
 0x00,
 0x00,
@@ -38,7 +38,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x0b,
-0x3c,
+0x78,
 0x00,
 0x00,
 0x00,
@@ -70,7 +70,7 @@ const char rmDspPlusArmPolicy[] = {
 0x00,
 0x00,
 0x00,
-0x27,
+0x62,
 0x00,
 0x00,
 0x00,
@@ -94,15 +94,40 @@ const char rmDspPlusArmPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x30,
+0x00,
+0x52,
+0x4d,
 0x5f,
-0x44,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x31,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
 0x6c,
+0x69,
 0x65,
-0x67,
-0x61,
+0x6e,
 0x74,
+0x32,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
 0x65,
+0x6e,
+0x74,
+0x33,
 0x00,
 0x52,
 0x4d,
@@ -113,6 +138,41 @@ const char rmDspPlusArmPolicy[] = {
 0x65,
 0x6e,
 0x74,
+0x34,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x35,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x36,
+0x00,
+0x52,
+0x4d,
+0x5f,
+0x43,
+0x6c,
+0x69,
+0x65,
+0x6e,
+0x74,
+0x37,
+0x00,
 0x00,
 0x00,
 0x00,
index a16d74d775d7c81570579ae4b6552b336e9ce1fe..98fdfe2cd7316443e0389858609bbe7ddca4333e 100644 (file)
Binary files a/device/k2k/policy_dsp_arm.dtb and b/device/k2k/policy_dsp_arm.dtb differ
index b071a3fb04a6f3272740e0d1477d0319369baaae..4eb3b64293150e812ce0009279d14cae9ab22130 100644 (file)
@@ -8,8 +8,14 @@
      * RM.  For an RM instance to be given permissions the name used to initialize it
      * must be present in this list */
     valid-instances = "RM_Server",
-                      "RM_Client_Delegate",
-                      "RM_Client";
+                      "RM_Client0",
+                      "RM_Client1",
+                      "RM_Client2",
+                      "RM_Client3",
+                      "RM_Client4",
+                      "RM_Client5",
+                      "RM_Client6",
+                      "RM_Client7";
        
     qmss {
         linkram-control {
index 9d27365a8a4ca82f68c780b8b9d529dd1a5b7028..5923cabaf69688d46bbf741b4d61d006de2dfccf 100644 (file)
@@ -47,10 +47,39 @@ extern "C" {
 /* RM external includes */
 #include <ti/drv/rm/rm.h>
 
+/* RM OSAL layer */
+#include <rm_osal.h>
+
 /* RM true/false definitions */
 #define RM_FALSE 0
 #define RM_TRUE  1
 
+/* Shared server enter critical section macro */
+#define RM_SS_INST_INV_ENTER_CS(csKey)                      \
+    Rm_osalBeginMemAccess((void *)rmInst, sizeof(Rm_Inst)); \
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {    \
+        csKey = Rm_osalCsEnter();                           \
+    }
+
+/* Shared server exit critical section macro */
+#define RM_SS_INST_WB_EXIT_CS(csKey)                          \
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {      \
+        Rm_osalEndMemAccess((void *)rmInst, sizeof(Rm_Inst)); \
+        Rm_osalCsExit(csKey);                                 \
+    }  
+
+/* Shared server invalidate macro */
+#define RM_SS_OBJ_INV(obj, objType)                          \
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {     \
+        Rm_osalBeginMemAccess((void *)obj, sizeof(objType)); \
+    }
+
+/* Shared server writeback macro */
+#define RM_SS_OBJ_WB(obj, objType)                         \
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {   \
+        Rm_osalEndMemAccess((void *)obj, sizeof(objType)); \
+    }    
+
 /* RM resource information */
 typedef struct {
     /* Resource name */
index d4d44182427e547cab8af91d7b1eff9124053091..04b83b89918aaa8f23581faf461a61c40c8a33ac 100644 (file)
@@ -44,6 +44,9 @@
 extern "C" {
 #endif
 
+/* RM external API includes */
+#include <ti/drv/rm/rm.h>
+
 /* RM internal includes */
 #include <ti/drv/rm/include/rm_treeloc.h>
 
@@ -62,9 +65,9 @@ typedef struct {
 int32_t rmNameServerAddObject(Rm_NameServerObjCfg *objCfg);
 int32_t rmNameServerFindObject(Rm_NameServerObjCfg *objCfg);
 int32_t rmNameServerDeleteObject(Rm_NameServerObjCfg *objCfg);
-void rmNameServerPrintObjects(Rm_NameServerTree *nameServerTree);
-Rm_NameServerTree *rmNameServerInit(void);
-void rmNameServerDelete(Rm_NameServerTree *nameServerTree);
+void rmNameServerPrintObjects(Rm_Handle rmHandle);
+void rmNameServerInit(Rm_Handle rmHandle);
+void rmNameServerDelete(Rm_Handle rmHandle);
 
 #ifdef __cplusplus
 }
index 1fae8c8135602a499e58a4707c24aadb53c6e264..bc743703fb7a9445a74c481139a45f37cd5d07c8 100644 (file)
@@ -139,25 +139,34 @@ typedef RB_HEAD(_Rm_AllocatorResourceTree, _Rm_ResourceNode) Rm_ResourceTree;
  ****************** Tree Node Function Definitions ********************
  **********************************************************************/
 
+void rmNameServerTreeInv(Rm_NameServerTree *treeRoot);
+void rmNameServerTreeWb(Rm_NameServerTree *treeRoot);
 Rm_NameServerNode *rmNameServerNodeNew(Rm_NameServerNodeCfg *nodeCfg);
 void rmNameServerNodeFree(Rm_NameServerNode *node);
 int rmNameServerNodeCompare(Rm_NameServerNode *node1, Rm_NameServerNode *node2); 
+void rmNameServerNodeInv(Rm_NameServerNode *node);
 
+void rmPolicyValidInstTreeInv(Rm_PolicyValidInstTree *treeRoot);
+void rmPolicyValidInstTreeWb(Rm_PolicyValidInstTree *treeRoot);
 Rm_PolicyValidInstNode *rmPolicyValidInstNodeNew(char *instName);
 void rmPolicyValidInstNodeFree(Rm_PolicyValidInstNode *node);
-int rmPolicyValidInstNodeCompare(Rm_PolicyValidInstNode *node1, Rm_PolicyValidInstNode *node2); 
+int rmPolicyValidInstNodeCompare(Rm_PolicyValidInstNode *node1, Rm_PolicyValidInstNode *node2);
+void rmPolicyValidInstNodeInv(Rm_PolicyValidInstNode *node);
 
+void rmResourceTreeInv(Rm_ResourceTree *treeRoot);
+void rmResourceTreeWb(Rm_ResourceTree *treeRoot);
 Rm_ResourceNode *rmResourceNodeNew(uint32_t resourceBase, uint32_t resourceLength);
 void rmResourceNodeFree(Rm_ResourceNode *node);
-int rmResourceNodeCompare(Rm_ResourceNode *node1, Rm_ResourceNode *node2); 
+int rmResourceNodeCompare(Rm_ResourceNode *node1, Rm_ResourceNode *node2);
+void rmResourceNodeInv(Rm_ResourceNode *node);
 
 /**********************************************************************
  ******************** Tree Prototype Generation ***********************
  **********************************************************************/
  
-RB_PROTOTYPE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, rmNameServerNodeCompare)
-RB_PROTOTYPE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, rmPolicyValidInstNodeCompare)
-RB_PROTOTYPE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, rmResourceNodeCompare)
+RB_PROTOTYPE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, rmNameServerNodeCompare, rmNameServerNodeInv)
+RB_PROTOTYPE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, rmPolicyValidInstNodeCompare, rmPolicyValidInstNodeInv)
+RB_PROTOTYPE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, rmResourceNodeCompare, rmResourceNodeInv)
 
 #ifdef __cplusplus
 }
diff --git a/rm.h b/rm.h
index 3f85dbf7405b5a74537338f35618f3a61773d1d9..1fe43462859a01a4dd7ac26cf392c2e0f143902e 100644 (file)
--- a/rm.h
+++ b/rm.h
@@ -252,73 +252,76 @@ extern "C" {
 #define RM_ERROR_GRL_INVALID_LINUX_ALIAS_FORMAT    RM_ERROR_BASE-14
 /** Error allocating memory for the service handle */
 #define RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED   RM_ERROR_BASE-15
-/** The RM instance service handle has already been opened */
-#define RM_ERROR_SERVICE_HANDLE_ALREADY_OPENED     RM_ERROR_BASE-16
 /** The RM instance service handle has already been closed */
-#define RM_ERROR_SERVICE_HANDLE_ALREADY_CLOSED     RM_ERROR_BASE-17
+#define RM_ERROR_SERVICE_HANDLE_ALREADY_CLOSED     RM_ERROR_BASE-16
 /** Global Resource List (GRL) resource node contains an unknown property */
-#define RM_ERROR_GRL_UNKNOWN_RESOURCE_PROPERTY     RM_ERROR_BASE-18
+#define RM_ERROR_GRL_UNKNOWN_RESOURCE_PROPERTY     RM_ERROR_BASE-17
 /** Could not find an allocator for the specified resource */
-#define RM_ERROR_RES_ALLOCATOR_DOES_NOT_EXIST      RM_ERROR_BASE-19
+#define RM_ERROR_RES_ALLOCATOR_DOES_NOT_EXIST      RM_ERROR_BASE-18
 /** A resource node is specified more than once in the Global Resource List (GRL) */
-#define RM_ERROR_GRL_RES_SPECIFIED_MORE_THAN_ONCE  RM_ERROR_BASE-20
+#define RM_ERROR_GRL_RES_SPECIFIED_MORE_THAN_ONCE  RM_ERROR_BASE-19
 /** No data was found at the GRL resource node's specified Linux alias path */
-#define RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS     RM_ERROR_BASE-21
+#define RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS     RM_ERROR_BASE-20
 /** RM server was not provided a Global Resource List (GRL) and global policy at initialization */
-#define RM_ERROR_INVALID_SERVER_CONFIGURATION      RM_ERROR_BASE-22
+#define RM_ERROR_INVALID_SERVER_CONFIGURATION      RM_ERROR_BASE-21
 /** Service request type not recognized */
-#define RM_ERROR_INVALID_SERVICE_TYPE              RM_ERROR_BASE-23
+#define RM_ERROR_INVALID_SERVICE_TYPE              RM_ERROR_BASE-22
 /** rmAllocPkt transport callout returned NULL for rmPkt */
-#define RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR         RM_ERROR_BASE-24
+#define RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR         RM_ERROR_BASE-23
 /** rmSendPkt transport callout returned error when attempting to send the rmPkt */
-#define RM_ERROR_TRANSPORT_SEND_ERROR              RM_ERROR_BASE-25
+#define RM_ERROR_TRANSPORT_SEND_ERROR              RM_ERROR_BASE-24
 /** A RM service transaction could not be created for the service request */
-#define RM_ERROR_SERVICE_TRANS_NOT_CREATED         RM_ERROR_BASE-26
+#define RM_ERROR_SERVICE_TRANS_NOT_CREATED         RM_ERROR_BASE-25
 /** RM service transaction could not be found in instance's transaction queue */
-#define RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST      RM_ERROR_BASE-27
+#define RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST      RM_ERROR_BASE-26
 /** NameServer does not exist in instance, cannot satisfy NameServer service request */
-#define RM_ERROR_NAMESERVER_DOES_NOT_EXIST         RM_ERROR_BASE-28
+#define RM_ERROR_NAMESERVER_DOES_NOT_EXIST         RM_ERROR_BASE-27
 /** Service request to add a name to the NameServer failed */
-#define RM_ERROR_NAMESERVER_NAME_ADD_FAILED        RM_ERROR_BASE-29
+#define RM_ERROR_NAMESERVER_NAME_ADD_FAILED        RM_ERROR_BASE-28
 /** Could not find name specified in service request in NameServer */
-#define RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST    RM_ERROR_BASE-30
+#define RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST    RM_ERROR_BASE-29
 /** Service request made on Client or CD when no transport established and no static policy registered */
-#define RM_ERROR_REQ_FAILED_NO_STATIC_POLICY       RM_ERROR_BASE-31
+#define RM_ERROR_REQ_FAILED_NO_STATIC_POLICY       RM_ERROR_BASE-30
 /** RM transport handle has not been registered with the RM instance */
-#define RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST   RM_ERROR_BASE-32
+#define RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST   RM_ERROR_BASE-31
 /** RM received a packet with an unknown RM packet type */
-#define RM_ERROR_RECEIVED_INVALID_PACKET_TYPE      RM_ERROR_BASE-33
+#define RM_ERROR_RECEIVED_INVALID_PACKET_TYPE      RM_ERROR_BASE-32
 /** RM response packet does not match any requests sent from instance */
-#define RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ   RM_ERROR_BASE-34
+#define RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ   RM_ERROR_BASE-33
 /** Server attempted to connect to another server or a CD attempted to connect to another CD or
  *  Client attempted to connect to another client */
-#define RM_ERROR_INVALID_REMOTE_INST_TYPE          RM_ERROR_BASE-35
+#define RM_ERROR_INVALID_REMOTE_INST_TYPE          RM_ERROR_BASE-34
 /** RM client attempted to register with more than one Server or CD or a CD attempted to register 
  *  with more than one Server */
-#define RM_ERROR_ALREADY_REGD_SERVER_OR_CD         RM_ERROR_BASE-36
+#define RM_ERROR_ALREADY_REGD_SERVER_OR_CD         RM_ERROR_BASE-35
 /** Service has both a NameServer name and a base, length, or alignment specified */
-#define RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT      RM_ERROR_BASE-37
+#define RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT      RM_ERROR_BASE-36
 /** Instance type not recognized */
-#define RM_ERROR_INVALID_INST_TYPE                 RM_ERROR_BASE-38
+#define RM_ERROR_INVALID_INST_TYPE                 RM_ERROR_BASE-37
 /** Linux DTB alias properties specified in GRL but no Linux DTB provided during server instance init */
-#define RM_ERROR_GRL_LINUX_ALIAS_BUT_NO_DTB        RM_ERROR_BASE-39
+#define RM_ERROR_GRL_LINUX_ALIAS_BUT_NO_DTB        RM_ERROR_BASE-38
 /** RM attempted to allocate a transport packet but the rmAllocPkt callout was not registered */
-#define RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD      RM_ERROR_BASE-40
+#define RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD      RM_ERROR_BASE-39
 /** RM attempted to send a packet but the rmSendPkt callout was not registered */
-#define RM_ERROR_TRANSPORT_SEND_NOT_REGD           RM_ERROR_BASE-41
+#define RM_ERROR_TRANSPORT_SEND_NOT_REGD           RM_ERROR_BASE-40
 /** RM attempted to send a response packet but the transport to the remote instance that sent
  *  the request packet is not registered */
-#define RM_ERROR_TRANSPORT_REMOTE_HNDL_NOT_REGD    RM_ERROR_BASE-42
+#define RM_ERROR_TRANSPORT_REMOTE_HNDL_NOT_REGD    RM_ERROR_BASE-41
 /** RM instance cannot be deleted with transports still registered */
-#define RM_ERROR_CANT_DELETE_WITH_REGD_TRANSPORT   RM_ERROR_BASE-43
+#define RM_ERROR_CANT_DELETE_WITH_REGD_TRANSPORT   RM_ERROR_BASE-42
 /** RM instance cannot be deleted with open service handle */
-#define RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL   RM_ERROR_BASE-44
+#define RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL   RM_ERROR_BASE-43
 /** RM instance cannot be deleted when there are transactions pending and the 
  *  ignorePendingServices parameter is set to false */
-#define RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS  RM_ERROR_BASE-45
+#define RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS  RM_ERROR_BASE-44
 /** Only the Server instance can be used to return resource status via the
  *  Rm_resourceStatus API */
-#define RM_ERROR_INVALID_RES_STATUS_INSTANCE       RM_ERROR_BASE-46 
+#define RM_ERROR_INVALID_RES_STATUS_INSTANCE       RM_ERROR_BASE-45
+/** RM Shared Server instances should always return a finished request since the instance has
+ *  access to the resource structures no matter what core the service is requested from */
+#define RM_ERROR_SHARED_SERVER_UNFINISHED_REQ      RM_ERROR_BASE-46
+/** RM Shared Server instances cannot register transports */
+#define RM_ERROR_SHARED_SERVER_CANNOT_REG_TRANS    RM_ERROR_BASE-47
 
 /** 
  * @brief Maximum number of characters allowed for RM instance, resource, and
@@ -343,12 +346,17 @@ typedef enum {
     Rm_instType_CLIENT_DELEGATE,
     /** RM Client */
     Rm_instType_CLIENT,
+    /** RM Shared Server - Server instance stored in shared memory that allows
+     *  multiple DSP cores to request services without the need to configure
+     *  and register transports.  Allows requests to be fulfilled from any DSP
+     *  core without blocking */
+    Rm_instType_SHARED_SERVER,
     /** DO NOT USE: Last type */
     Rm_instType_LAST
 } Rm_InstType;
 
 /**
- * @brief RM server initialization configurations
+ * @brief RM server (includes shared server) initialization configurations
  */
 typedef struct {
     /** Pointer to the device global resource list (GRL).  The GRL contains 
@@ -468,7 +476,8 @@ void Rm_instanceStatus(Rm_Handle rmHandle);
  *      result in a new RM instance.  However, a network of RM instances
  *      can have only one RM Server.  If an application has multiple RM
  *      Servers the resources managed by each server must be mutually
- *      exclusive.
+ *      exclusive.  Additionally if an application has multiple RM shared
+ *      servers the resources they manage must be mutually exclusive as well
  *
  *      If any errors are encountered during the initialization process
  *      the Rm_Handle returned will be NULL.
index 8825204def9eb63dd86ce62625397f2d58c34dd6..e9245768b3ba94c812cf0f339b554dd42d28c99d 100644 (file)
--- a/rm_osal.h
+++ b/rm_osal.h
 
 extern void *Osal_rmMalloc (uint32_t num_bytes);
 extern void  Osal_rmFree (void *ptr, uint32_t size);
+extern void *Osal_rmCsEnter (void);
+extern void  Osal_rmCsExit (void *CsHandle);
+extern void  Osal_rmBeginMemAccess (void *ptr, uint32_t size);
+extern void  Osal_rmEndMemAccess (void *ptr, uint32_t size);
 extern void *Osal_rmTaskBlockCreate (void);
 extern void  Osal_rmTaskBlock (void *handle);
 extern void  Osal_rmTaskUnblock (void *handle);
@@ -122,6 +126,92 @@ extern void  Osal_rmLog (char *fmt, ... );
  */
 #define Rm_osalFree               Osal_rmFree
 
+/**
+ * @brief   The function is used to enter a critical section.
+ *          Function protects against 
+ *      
+ *          access from multiple cores 
+ *          and 
+ *          access from multiple threads on single core
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void *Osal_rmCsEnter (void)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  Not applicable.
+ *
+ *  <b> Return Value </b>
+ *  @n  Handle used to lock critical section
+ */
+#define Rm_osalCsEnter            Osal_rmCsEnter
+
+/**
+ * @brief   The function is used to exit a critical section 
+ *          protected using Osal_rmCsEnter() API.
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void Osal_rmCsExit (void *CsHandle)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  Handle for unlocking critical section.
+ *
+ *  <b> Return Value </b>
+ *  @n  Not applicable.
+ */
+#define Rm_osalCsExit             Osal_rmCsExit
+
+/**
+ * @brief   The function is used to indicate that a block of memory is 
+ *          about to be accessed. If the memory block is cached then this 
+ *          indicates that the application would need to ensure that the 
+ *          cache is updated with the data from the actual memory.
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void Osal_rmBeginMemAccess (void *ptr, uint32_t size)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  Address of memory block
+ *  @n  Size of memory block
+ *
+ *  <b> Return Value </b>
+ *  @n  Not applicable.
+ */
+#define Rm_osalBeginMemAccess     Osal_rmBeginMemAccess
+
+/**
+ * @brief   The function is used to indicate that the block of memory has 
+ *          finished being accessed. If the memory block is cached then the 
+ *          application would need to ensure that the contents of the cache 
+ *          are updated immediately to the actual memory. 
+ *
+ * <b> Prototype: </b>
+ *  The following is the C prototype for the expected OSAL API.
+ *
+ *  @verbatim
+       void Osal_rmEndMemAccess (void *ptr, uint32_t size)
+    @endverbatim
+ *      
+ *  <b> Parameter </b>
+ *  @n  Address of memory block
+ *  @n  Size of memory block
+ *
+ *  <b> Return Value </b>
+ *  @n  Not applicable.
+ */
+#define Rm_osalEndMemAccess       Osal_rmEndMemAccess
+
 /**
  * @brief   The macro is used by RM to create a task blocking
  *          mechanism allowing a RM instance to block when it
index 82441b0806334783d9c0179ddb69c189a8387745..f805f8cd359d46b75dce09cc67f2e7c2b120ae60 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
@@ -50,6 +50,7 @@
 #include <ti/drv/rm/rm_transport.h>
 
 /* RM internal includes */
+#include <ti/drv/rm/include/rm_internal.h>
 #include <ti/drv/rm/include/rm_loc.h>
 #include <ti/drv/rm/include/rm_allocatorloc.h>
 #include <ti/drv/rm/include/rm_transportloc.h>
@@ -66,7 +67,7 @@
  ************************** Globals ***********************************
  **********************************************************************/
 
-/** @brief Global Variable which describes the RM Version Information */
+/* Global Variable which describes the RM Version Information */
 const char  rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;
 
 /**********************************************************************
@@ -438,6 +439,9 @@ static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 if ((transaction->resourceInfo.base == 0) &&
                     (transaction->resourceInfo.length == 0) &&
                     (transaction->resourceInfo.alignment == 0)) {
+                    if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                        rmNameServerTreeInv(rmInst->u.server.nameServer);
+                    }
                     memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
                     nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
                     nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
@@ -503,6 +507,9 @@ static void freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 if ((transaction->resourceInfo.base == 0) &&
                     (transaction->resourceInfo.length == 0) &&
                     (transaction->resourceInfo.alignment == 0)) {
+                    if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                        rmNameServerTreeInv(rmInst->u.server.nameServer);
+                    }                    
                     memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
                     nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
                     nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
@@ -677,6 +684,9 @@ static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
         case Rm_service_RESOURCE_GET_BY_NAME:
         case Rm_service_RESOURCE_UNMAP_NAME:             
             if (rmInst->u.server.nameServer) {
+                if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                    rmNameServerTreeInv(rmInst->u.server.nameServer);
+                }                
                 memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
                 nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
                 nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
@@ -698,6 +708,10 @@ static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {
                     transaction->state = rmNameServerDeleteObject(&nameServerObjCfg);
                 }
+                
+                if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                    rmNameServerTreeWb(rmInst->u.server.nameServer);
+                }
             }
             else {
                 transaction->state = RM_ERROR_NAMESERVER_DOES_NOT_EXIST;
@@ -839,20 +853,29 @@ void rmProcessRouter (Rm_Inst *rmInst, Rm_Transaction *transaction)
 int32_t Rm_resourceStatus(Rm_Handle rmServerHandle, int printResources)
 {
     Rm_Inst         *rmInst = (Rm_Inst *)rmServerHandle;
-    Rm_Allocator    *allocator = rmInst->u.server.allocators;
+    Rm_Allocator    *allocator = NULL;
     Rm_Owner        *owners;
     Rm_ResourceTree *treeRoot;
     Rm_ResourceNode *treeNode;
     int32_t          totalResOwners = 0;
+    void            *key; 
 
-    if (rmInst->instType == Rm_instType_SERVER) {
+    RM_SS_INST_INV_ENTER_CS(key);
+
+    if ((rmInst->instType == Rm_instType_SERVER) ||
+        (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+        allocator = rmInst->u.server.allocators;
         while (allocator) {
+            RM_SS_OBJ_INV(allocator, Rm_Allocator);
             if (printResources) {
                 Rm_osalLog("Resource: %s\n", allocator->resourceName);
             }
 
             treeRoot = allocator->allocatorRootEntry;
-
+            RM_SS_OBJ_INV(treeRoot, Rm_ResourceTree);
+            if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                rmResourceTreeInv(treeRoot);
+            }
             RB_FOREACH(treeNode, _Rm_AllocatorResourceTree, treeRoot) {
                 if (printResources) {
                     if ((treeNode->base >= 65536) ||
@@ -875,6 +898,7 @@ int32_t Rm_resourceStatus(Rm_Handle rmServerHandle, int printResources)
                 else {
                     owners = treeNode->ownerList;
                     while (owners) {
+                        RM_SS_OBJ_INV(owners, Rm_Owner);
                         if (printResources) {
                             Rm_osalLog("%s ", owners->instNameNode->name);
                         }
@@ -886,16 +910,17 @@ int32_t Rm_resourceStatus(Rm_Handle rmServerHandle, int printResources)
                     }
                 }
             }        
-            allocator = allocator->nextAllocator;
+            allocator = allocator->nextAllocator; 
         }
         if (printResources) {
-            rmNameServerPrintObjects(rmInst->u.server.nameServer);
+            rmNameServerPrintObjects((Rm_Handle)rmInst);
         }
     }
     else {
         totalResOwners = RM_ERROR_INVALID_RES_STATUS_INSTANCE;
-    }
+    }  
 
+    RM_SS_INST_WB_EXIT_CS(key);
     return(totalResOwners);
 }
 
@@ -908,8 +933,11 @@ int32_t Rm_resourceStatus(Rm_Handle rmServerHandle, int printResources)
 void Rm_instanceStatus(Rm_Handle rmHandle)
 {
     Rm_Inst        *rmInst = (Rm_Inst *)rmHandle;
-    Rm_Transport   *transportList = rmInst->transports;
-    Rm_Transaction *transactionQ = rmInst->transactionQueue;
+    Rm_Transport   *transportList = NULL;
+    Rm_Transaction *transactionQ = NULL;
+    void           *key; 
+
+    RM_SS_INST_INV_ENTER_CS(key);
 
     Rm_osalLog("Instance name: %s\n", rmInst->instName);
     Rm_osalLog("Handle: 0x%08x\n", rmHandle);    
@@ -919,13 +947,18 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
     else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
         Rm_osalLog("Type:   Client Delegate\n");
     }
-    else {
+    else if (rmInst->instType == Rm_instType_CLIENT) {
         Rm_osalLog("Type:   Client\n");
     }
-
+    else if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+        Rm_osalLog("Type:   Shared Server\n");
+    }
+    
+    transportList = rmInst->transports;
     if (transportList) {
         Rm_osalLog("\nRegistered Transports:\n");
         while (transportList) {
+            RM_SS_OBJ_INV(transportList, Rm_Transport);
             Rm_osalLog("    Remote instName:    %s\n", transportList->remoteInstName);
             if (transportList->remoteInstType == Rm_instType_SERVER) {
                 Rm_osalLog("    Remote instType:    Server\n");
@@ -942,9 +975,11 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
         }
     }
 
+    transactionQ = rmInst->transactionQueue;
     if (transactionQ) {
         Rm_osalLog("\nQueued Service Transactions:\n");
         while (transactionQ) {
+            RM_SS_OBJ_INV(transactionQ, Rm_Transaction);
             Rm_osalLog("    Service type:       %d\n", transactionQ->type);
             Rm_osalLog("    Service ID:         %d\n", transactionQ->localId);
             Rm_osalLog("    Service srcInstName %s\n", transactionQ->serviceSrcInstName);
@@ -958,6 +993,7 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
             transactionQ = transactionQ->nextTransaction;
         }    
     }
+    RM_SS_INST_WB_EXIT_CS(key);    
 }
 
 /* FUNCTION PURPOSE: RM instance creation and initialization
@@ -971,7 +1007,7 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
     Rm_Inst *rmInst = NULL;
     void    *globalResourceDtb = NULL;
     void    *linuxResourceDtb = NULL;
-    int      addLinux = RM_FALSE;
+    int      addLinux = RM_FALSE;   
 
     *result = RM_OK;
     
@@ -996,7 +1032,8 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
     rmInst->instType = initCfg->instType;    
     strncpy (rmInst->instName, initCfg->instName, RM_NAME_MAX_CHARS);
 
-    if (rmInst->instType == Rm_instType_SERVER) {
+    if ((rmInst->instType == Rm_instType_SERVER) ||
+        (rmInst->instType == Rm_instType_SHARED_SERVER)) {
         if (!initCfg->instCfg.serverCfg.globalResourceList ||
             !initCfg->instCfg.serverCfg.globalPolicy) {
             *result = RM_ERROR_INVALID_SERVER_CONFIGURATION;
@@ -1025,7 +1062,7 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
             goto errorExit;
         }
         else {
-            rmInst->u.server.nameServer = rmNameServerInit();
+            rmNameServerInit((Rm_Handle)rmInst);
 
             globalResourceDtb = initCfg->instCfg.serverCfg.globalResourceList;
 
@@ -1035,7 +1072,7 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
 
             if (*result != RM_OK) {
                 rmAllocatorDeleteResources(rmInst->u.server.allocators);
-                rmNameServerDelete(rmInst->u.server.nameServer);
+                rmNameServerDelete((Rm_Handle)rmInst);
                 goto errorExit;
             }
         }
@@ -1075,9 +1112,15 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
         }
     }
 
-    /* Create the instance's task blocking mechanism */
-    rmInst->blockHandle = Rm_osalTaskBlockCreate();
-    
+    if (initCfg->instType == Rm_instType_SHARED_SERVER) {
+        /* Invalidate the instance for other cores */
+        Rm_osalEndMemAccess ((void *)rmInst, sizeof(Rm_Inst));
+    }
+    else {
+        /* Create the instance's task blocking mechanism */
+        rmInst->blockHandle = Rm_osalTaskBlockCreate();
+    }
+
     return ((Rm_Handle) rmInst);
 errorExit:
     if (rmInst) {
@@ -1095,6 +1138,9 @@ errorExit:
 int32_t Rm_delete(Rm_Handle rmHandle, int ignorePendingServices)
 {
     Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+    void    *key; 
+
+    RM_SS_INST_INV_ENTER_CS(key);
 
     if (rmInst->serviceHandle) {
         return (RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL);
@@ -1106,10 +1152,11 @@ int32_t Rm_delete(Rm_Handle rmHandle, int ignorePendingServices)
         return (RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS);
     }
 
-    if (rmInst->instType == Rm_instType_SERVER) {
+    if ((rmInst->instType == Rm_instType_SERVER) ||
+        (rmInst->instType == Rm_instType_SHARED_SERVER)) {
         rmAllocatorDeleteResources(rmInst->u.server.allocators);
         rmPolicyFreeValidInstTree(rmInst->u.server.globalValidInstTree);
-        rmNameServerDelete(rmInst->u.server.nameServer);
+        rmNameServerDelete(rmHandle);
     }
     else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
         rmPolicyFreeValidInstTree(rmInst->u.cd.staticValidInstTree);
@@ -1122,11 +1169,19 @@ int32_t Rm_delete(Rm_Handle rmHandle, int ignorePendingServices)
     while(rmInst->transactionQueue) {
         rmTransactionQueueDelete(rmInst, rmInst->transactionQueue->localId);
     }
-    
-    /* Delete the instance's task blocking mechanism */
-    Rm_osalTaskBlockDelete(rmInst->blockHandle);
 
-    Rm_osalFree((void *)rmInst, sizeof(Rm_Inst)); 
+    if (rmInst->instType != Rm_instType_SHARED_SERVER) {
+        /* Delete the instance's task blocking mechanism */
+        Rm_osalTaskBlockDelete(rmInst->blockHandle);
+    }
+    else {
+        Rm_osalEndMemAccess((void *)rmInst, sizeof(Rm_Inst));
+    }
+
+    Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {    
+        Rm_osalCsExit(key);   
+    }
     return (RM_OK);
 }
 
index 230e646e4be562b90ac312941f31740ac27e3c3b..070e49b098c01d70cba98dd5846b2daa791aefdd 100644 (file)
@@ -1130,6 +1130,9 @@ static int32_t allocatorExtractGrlResProps(Rm_Handle rmHandle, const char *resou
                                                             resourceProperties->nsAssignLen, &retVal);
             if (nsAssignments) {
                 nsAssignmentBasePtr = nsAssignments;
+                if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                    rmNameServerTreeInv(rmInst->u.server.nameServer);
+                }                  
                 while (nsAssignments) {
                     memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
                     nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
@@ -1140,6 +1143,9 @@ static int32_t allocatorExtractGrlResProps(Rm_Handle rmHandle, const char *resou
                     rmNameServerAddObject(&nameServerObjCfg);
                     nsAssignments = nsAssignments->nextNsAssignment;
                 }
+                if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+                    rmNameServerTreeWb(rmInst->u.server.nameServer);
+                }                
                 rmDtbUtilResFreeNsAssignmentList(nsAssignmentBasePtr);
             }
         }
index ec6e4748afcfc376bff313b24648752f649403ba..401bf323b69362836fbf4c3971f9d8fd349c366e 100644 (file)
@@ -46,6 +46,8 @@
 #include <ti/drv/rm/rm.h>
 
 /* RM internal API includes */
+#include <ti/drv/rm/include/rm_internal.h>
+#include <ti/drv/rm/include/rm_loc.h>
 #include <ti/drv/rm/include/rm_nameserverloc.h>
 #include <ti/drv/rm/include/rm_treeloc.h>
 
@@ -139,11 +141,16 @@ int32_t rmNameServerDeleteObject(Rm_NameServerObjCfg *objCfg)
  * DESCRIPTION: Prints the names and the resources they're mapped
  *              to for all objects stored in the NameServer tree.
  */
-void rmNameServerPrintObjects(Rm_NameServerTree *nameServerTree)
+void rmNameServerPrintObjects(Rm_Handle rmHandle)
 {
+    Rm_Inst           *rmInst = (Rm_Inst *)rmHandle;
+    Rm_NameServerTree *root = rmInst->u.server.nameServer;
     Rm_NameServerNode *node;
 
-    RB_FOREACH(node, _Rm_NameServerTree, nameServerTree) {               
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+        rmNameServerTreeInv(root);
+    }
+    RB_FOREACH(node, _Rm_NameServerTree, root) {
         Rm_osalLog("Name: %s resourceName: %s base: %d length: %d\n", node->objName, node->resourceName,
                                                                       node->resourceBase, node->resourceLength);
     }
@@ -154,14 +161,15 @@ void rmNameServerPrintObjects(Rm_NameServerTree *nameServerTree)
  * DESCRIPTION: Creates and initializes the NameServer tree
  *              root entry.
  */
-Rm_NameServerTree *rmNameServerInit(void)
+void rmNameServerInit(Rm_Handle rmHandle)
 {
+    Rm_Inst           *rmInst = (Rm_Inst *)rmHandle;
     Rm_NameServerTree *rootEntry = NULL;
 
     rootEntry = Rm_osalMalloc(sizeof(Rm_NameServerTree));
     RB_INIT(rootEntry);
-
-    return(rootEntry);
+    RM_SS_OBJ_WB(rootEntry, Rm_NameServerTree);
+    rmInst->u.server.nameServer = rootEntry;
 }
 
 /* FUNCTION PURPOSE: Deletes the NameServer tree
@@ -169,20 +177,31 @@ Rm_NameServerTree *rmNameServerInit(void)
  * DESCRIPTION: Removes all objects from the NameServer tree
  *              and deletes the NameServer tree root node.
  */
-void rmNameServerDelete(Rm_NameServerTree *nameServerTree)
+void rmNameServerDelete(Rm_Handle rmHandle)
 {
+    Rm_Inst             *rmInst = (Rm_Inst *)rmHandle;
+    Rm_NameServerTree   *treeRoot = rmInst->u.server.nameServer;
     Rm_NameServerNode   *node;
     Rm_NameServerNode   *nextNode;
     Rm_NameServerObjCfg  objCfg;
+
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+        rmNameServerTreeInv(treeRoot);
+    }
     
-    for (node = RB_MIN(_Rm_NameServerTree, nameServerTree); node != NULL; node = nextNode) {
-        nextNode = RB_NEXT(_Rm_NameServerTree, nameServerTree, node);
-        objCfg.nameServerTree = nameServerTree;
+    for (node = RB_MIN(_Rm_NameServerTree, treeRoot); node != NULL; node = nextNode) {
+        nextNode = RB_NEXT(_Rm_NameServerTree, treeRoot, node);
+        objCfg.nameServerTree = treeRoot;
         objCfg.nodeCfg.objName = node->objName;
         rmNameServerDeleteObject(&objCfg);
-    }       
-    if (RB_MIN(_Rm_NameServerTree, nameServerTree) == NULL) {
-        Rm_osalFree((void *)nameServerTree, sizeof(Rm_NameServerTree));
-    }        
+    }
+
+    /* Don't need to writeback tree node changes since NameServer will be removed
+     * from instance */
+     
+    if (RB_MIN(_Rm_NameServerTree, treeRoot) == NULL) {
+        Rm_osalFree((void *)treeRoot, sizeof(Rm_NameServerTree));
+    }
+    rmInst->u.server.nameServer = NULL;
 }
 
index c689ee4a3f5de036806755fdf61b543f0f84a38b..aa6b61331c71ecb9fc90392196c641dab7725930 100644 (file)
@@ -94,6 +94,9 @@ void Rm_serviceHandler (void *rmHandle, const Rm_ServiceReqInfo *serviceRequest,
 {
     Rm_Inst        *rmInst = (Rm_Inst *)rmHandle;
     Rm_Transaction *transaction;
+    void           *key;     
+
+    RM_SS_INST_INV_ENTER_CS(key);
 
     if (rmInst->isLocked) {
         serviceResponse->serviceState = RM_SERVICE_DENIED_RM_INSTANCE_LOCKED;
@@ -126,68 +129,81 @@ void Rm_serviceHandler (void *rmHandle, const Rm_ServiceReqInfo *serviceRequest,
             
         memset((void *)serviceResponse, 0, sizeof(Rm_ServiceRespInfo));
 
-        if ((transaction->state == RM_SERVICE_PROCESSING) && (transaction->callback.serviceCallback == NULL)) {
-            /* Block until response is received.  Response will be received in transaction. */
-            Rm_osalTaskBlock(rmInst->blockHandle);
-        }
-
-        serviceResponse->rmHandle = rmHandle;
-        serviceResponse->serviceState = transaction->state;
-        if ((serviceResponse->serviceState == RM_SERVICE_PROCESSING) ||
-            (serviceResponse->serviceState == RM_SERVICE_APPROVED_STATIC)) {
-            /* Service still being processed.  Static requests will have their validation responses sent once
-             * all transports have been established.  Provide transaction ID back to component so it can sort 
-             * service responses received via callback function */
-            serviceResponse->serviceId = transaction->localId;
-        }
-
-        if ((serviceResponse->serviceState == RM_SERVICE_APPROVED) ||
-            (serviceResponse->serviceState == RM_SERVICE_APPROVED_STATIC)) {
-            strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
-            serviceResponse->resourceBase = transaction->resourceInfo.base;
-            serviceResponse->resourceLength = transaction->resourceInfo.length;
-        }
-
-        /* Transactions still processing not deleted from queue.  Includes static transactions which will be 
-         * verified once all transports are up */
-        if ((serviceResponse->serviceState != RM_SERVICE_PROCESSING) &&
-            (serviceResponse->serviceState != RM_SERVICE_APPROVED_STATIC)) {
+        if ((rmInst->instType == Rm_instType_SHARED_SERVER) && 
+            (transaction->state == RM_SERVICE_PROCESSING)) {
+            /* Shared Server should always return a fully processed transaction */
+            serviceResponse->serviceState = RM_ERROR_SHARED_SERVER_UNFINISHED_REQ;
             rmTransactionQueueDelete(rmInst, transaction->localId);
         }
+        else {
+            if ((transaction->state == RM_SERVICE_PROCESSING) && 
+                (transaction->callback.serviceCallback == NULL)) {
+                /* Block until response is received.  Response will be received in transaction. */
+                Rm_osalTaskBlock(rmInst->blockHandle);
+            }
+
+            serviceResponse->rmHandle = rmHandle;
+            serviceResponse->serviceState = transaction->state;
+            if ((serviceResponse->serviceState == RM_SERVICE_PROCESSING) ||
+                (serviceResponse->serviceState == RM_SERVICE_APPROVED_STATIC)) {
+                /* Service still being processed.  Static requests will have their validation responses sent once
+                 * all transports have been established.  Provide transaction ID back to component so it can sort 
+                 * service responses received via callback function */
+                serviceResponse->serviceId = transaction->localId;
+            }
+
+            if ((serviceResponse->serviceState == RM_SERVICE_APPROVED) ||
+                (serviceResponse->serviceState == RM_SERVICE_APPROVED_STATIC)) {
+                strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+                serviceResponse->resourceBase = transaction->resourceInfo.base;
+                serviceResponse->resourceLength = transaction->resourceInfo.length;
+            }
+
+            /* Transactions still processing not deleted from queue including static transactions which will be 
+             * verified once all transports are up */
+            if ((serviceResponse->serviceState != RM_SERVICE_PROCESSING) &&
+                (serviceResponse->serviceState != RM_SERVICE_APPROVED_STATIC)) {
+                rmTransactionQueueDelete(rmInst, transaction->localId);
+            }
+        }
     }
     else {
         serviceResponse->serviceState = RM_ERROR_SERVICE_TRANS_NOT_CREATED;    
     }
+    RM_SS_INST_WB_EXIT_CS(key);
     return;
 }
 
 /* FUNCTION PURPOSE: Opens the RM instance service handle
  ***********************************************************************
  * DESCRIPTION: Returns the service handle for an RM instance.  Only
- *              one service handle can be opened per instance.
+ *              one service handle is opened per instance.
  */
 Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result)
 {
     Rm_Inst          *rmInst = (Rm_Inst *)rmHandle;
-    Rm_ServiceHandle *newServiceHandle = NULL;
+    Rm_ServiceHandle *serviceHandle = NULL;
+    void             *key;
+    
+    RM_SS_INST_INV_ENTER_CS(key);
 
     *result = RM_OK;
 
-    if (rmInst->serviceHandle == NULL) {
-        newServiceHandle = Rm_osalMalloc(sizeof(Rm_ServiceHandle));
-        if (newServiceHandle) {
-            newServiceHandle->rmHandle = rmHandle;
-            newServiceHandle->Rm_serviceHandler = Rm_serviceHandler;
-            rmInst->serviceHandle = newServiceHandle;
+    serviceHandle = rmInst->serviceHandle;
+    if (serviceHandle == NULL) {
+        serviceHandle = Rm_osalMalloc(sizeof(Rm_ServiceHandle));
+        if (serviceHandle) {
+            serviceHandle->rmHandle = rmHandle;
+            serviceHandle->Rm_serviceHandler = Rm_serviceHandler;
+            RM_SS_OBJ_WB(serviceHandle, Rm_ServiceHandle);
+            rmInst->serviceHandle = serviceHandle;
         }
         else {
             *result = RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED;
         }
     }
-    else {
-        *result = RM_ERROR_SERVICE_HANDLE_ALREADY_OPENED;
-    }
-    return (newServiceHandle);
+    RM_SS_INST_WB_EXIT_CS(key);
+    return (serviceHandle);
 }
 
 /* FUNCTION PURPOSE: Closes the RM instance service handle
@@ -198,6 +214,9 @@ int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle)
 {
     Rm_Inst *rmInst = (Rm_Inst *)rmServiceHandle->rmHandle;
     int32_t  retVal = RM_OK;
+    void    *key;
+
+    RM_SS_INST_INV_ENTER_CS(key);
 
     if (rmInst->serviceHandle) {
         Rm_osalFree((void *)rmServiceHandle, sizeof(Rm_ServiceHandle));
@@ -206,6 +225,7 @@ int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle)
     else {
         retVal = RM_ERROR_SERVICE_HANDLE_ALREADY_CLOSED;
     }
+    RM_SS_INST_WB_EXIT_CS(key);
     return(retVal);
 }
 
index 6cd585e5d38c7c8adf9d074b9eba0cb0da561298..d2e192283ae967f33ae9a0f7428aeba1dc7a705b 100644 (file)
@@ -203,19 +203,31 @@ Rm_TransportHandle Rm_transportRegister (const Rm_TransportCfg *transportCfg, in
 {\r
     Rm_Inst      *rmInst = (Rm_Inst *) transportCfg->rmHandle;\r
     Rm_Transport *transport = NULL;\r
+    void         *key;\r
 \r
     *result = RM_OK;\r
 \r
-    /* RM Servers cannot connect to other Servers.  \r
+    RM_SS_INST_INV_ENTER_CS(key);\r
+\r
+    /* Shared servers cannot connect to anyone */\r
+    if (rmInst->instType == Rm_instType_SHARED_SERVER) {\r
+        *result = RM_ERROR_SHARED_SERVER_CANNOT_REG_TRANS;\r
+        goto errorExit;\r
+    }\r
+\r
+    /* No one can connect to a shared server\r
+     * RM Servers cannot connect to other Servers.  \r
      * RM Client Delegates cannot connect to other Client Delegates.\r
      * RM Clients cannot connect to other Clients */\r
-    if (((rmInst->instType == Rm_instType_SERVER) &&\r
+    if ((transportCfg->remoteInstType == Rm_instType_SHARED_SERVER) ||\r
+        ((rmInst->instType == Rm_instType_SERVER) &&\r
          (transportCfg->remoteInstType == Rm_instType_SERVER)) ||\r
         ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) ||\r
         ((rmInst->instType == Rm_instType_CLIENT) &&\r
          (transportCfg->remoteInstType == Rm_instType_CLIENT))) {\r
         *result = RM_ERROR_INVALID_REMOTE_INST_TYPE;\r
+        goto errorExit;\r
     }\r
 \r
     /* Verify Clients are not registering with more than one Client Delegate or Server. And\r
@@ -226,23 +238,25 @@ Rm_TransportHandle Rm_transportRegister (const Rm_TransportCfg *transportCfg, in
          ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
           (transportCfg->remoteInstType == Rm_instType_SERVER)))) {\r
         *result = RM_ERROR_ALREADY_REGD_SERVER_OR_CD;\r
+        goto errorExit;\r
     }         \r
     \r
     if (!transportCfg->transportCallouts.rmAllocPkt) {\r
         *result = RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD;\r
+        goto errorExit;\r
     }\r
     else if (!transportCfg->transportCallouts.rmSendPkt) {\r
         *result = RM_ERROR_TRANSPORT_SEND_NOT_REGD;\r
+        goto errorExit;\r
     }\r
 \r
-    if (*result == RM_OK) {\r
-        transport = transportAdd(transportCfg);\r
-        if ((transport->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
-            (transport->remoteInstType == Rm_instType_SERVER)) {\r
-            rmInst->registeredWithDelegateOrServer = RM_TRUE;\r
-        }\r
+    transport = transportAdd(transportCfg);\r
+    if ((transport->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
+        (transport->remoteInstType == Rm_instType_SERVER)) {\r
+        rmInst->registeredWithDelegateOrServer = RM_TRUE;\r
     }\r
-\r
+errorExit:\r
+    RM_SS_INST_WB_EXIT_CS(key);    \r
     return ((Rm_TransportHandle) transport);\r
 }\r
 \r
@@ -256,7 +270,7 @@ int32_t Rm_transportUnregister(Rm_TransportHandle transportHandle)
 {\r
     Rm_Transport *transport = (Rm_Transport *)transportHandle;\r
     Rm_Inst      *rmInst = (Rm_Inst *)transport->rmHandle;\r
-    int32_t       retVal = RM_OK;  \r
+    int32_t       retVal = RM_OK;\r
 \r
     if (transportIsRegistered(transport->rmHandle, transport)) {\r
         if ((transport->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
index ee5c92468c4850a07d7cfad50b76de379953b959..a5e7ec2b76cb6e7096b0bc95d0fbe1b68474f767 100644 (file)
  ********************* NameServer Tree Functions **********************
  **********************************************************************/
 
+/* FUNCTION PURPOSE: Invalidates an entire NameServer tree
+ ***********************************************************************
+ * DESCRIPTION: Uses the cache handling versions of the RB tree
+ *              macros to walk an entire NameServer tree and invalidate
+ *              it.
+ */
+void rmNameServerTreeInv(Rm_NameServerTree *treeRoot)
+{
+    Rm_NameServerNode *node;
+
+    /* Invalidate the tree root */
+    Rm_osalBeginMemAccess((void *)treeRoot, sizeof(Rm_NameServerTree));
+    /* Walk the tree which will invalidate each element in the tree */
+    node = RB_MIN_CACHED(_Rm_NameServerTree, treeRoot);
+    while (node) {
+        node = RB_NEXT_CACHED(_Rm_NameServerTree, treeRoot, node);
+    }
+}
+
+/* FUNCTION PURPOSE: Writebacks an entire NameServer tree
+ ***********************************************************************
+ * DESCRIPTION: Walks the entire NameServer tree writing back
+ *              each element to shared memory
+ */
+void rmNameServerTreeWb(Rm_NameServerTree *treeRoot)
+{
+    Rm_NameServerNode *node;
+
+    /* Writeback each element in the tree */
+    node = RB_MIN(_Rm_NameServerTree, treeRoot);
+    do {
+        Rm_osalEndMemAccess((void *)node, sizeof(Rm_NameServerNode));
+        node = RB_NEXT(_Rm_NameServerTree, treeRoot, node);
+    } while (node);
+
+    /* Writeback the tree root */
+    Rm_osalEndMemAccess((void *)treeRoot, sizeof(Rm_NameServerTree));
+}
+
 /* FUNCTION PURPOSE: Creates a new NameServer tree node
  ***********************************************************************
  * DESCRIPTION: Creates a new NameServer tree node with the
@@ -101,13 +140,62 @@ int rmNameServerNodeCompare(Rm_NameServerNode *node1, Rm_NameServerNode *node2)
     return(strncmp(node1->objName, node2->objName, RM_NAME_MAX_CHARS));
 }
 
+/* FUNCTION PURPOSE: Invalidates a NameServer tree node
+ ***********************************************************************
+ * DESCRIPTION: Uses RM OSAL layer to invalidate the specified
+ *              NameServer tree node.
+ */
+void rmNameServerNodeInv(Rm_NameServerNode *node)
+{
+    Rm_osalBeginMemAccess((void *)node, sizeof(Rm_NameServerNode));
+}
+
 /* Generate the NameServer tree manipulation functions */
-RB_GENERATE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, rmNameServerNodeCompare);
+RB_GENERATE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, rmNameServerNodeCompare, rmNameServerNodeInv);
 
 /**********************************************************************
  *************** Policy Valid Instance Tree Functions *****************
  **********************************************************************/
 
+/* FUNCTION PURPOSE: Invalidates an entire valid instance tree
+ ***********************************************************************
+ * DESCRIPTION: Uses the cache handling versions of the RB tree
+ *              macros to walk an entire valid instance tree and invalidate
+ *              it.
+ */
+void rmPolicyValidInstTreeInv(Rm_PolicyValidInstTree *treeRoot)
+{
+    Rm_PolicyValidInstNode *node;
+
+    /* Invalidate the tree root */
+    Rm_osalBeginMemAccess((void *)treeRoot, sizeof(Rm_PolicyValidInstTree));
+    /* Walk the tree which will invalidate each element in the tree */
+    node = RB_MIN_CACHED(_Rm_PolicyValidInstTree, treeRoot);
+    while (node) {
+        node = RB_NEXT_CACHED(_Rm_PolicyValidInstTree, treeRoot, node);
+    }
+}
+
+/* FUNCTION PURPOSE: Writebacks an entire valid instance tree
+ ***********************************************************************
+ * DESCRIPTION: Walks the entire valid instance tree writing back
+ *              each element to shared memory
+ */
+void rmPolicyValidInstTreeWb(Rm_PolicyValidInstTree *treeRoot)
+{
+    Rm_PolicyValidInstNode *node;
+
+    /* Writeback each element in the tree */
+    node = RB_MIN(_Rm_PolicyValidInstTree, treeRoot);
+    do {
+        Rm_osalEndMemAccess((void *)node, sizeof(Rm_PolicyValidInstNode));
+        node = RB_NEXT(_Rm_PolicyValidInstTree, treeRoot, node);
+    } while (node);
+
+    /* Writeback the tree root */
+    Rm_osalEndMemAccess((void *)treeRoot, sizeof(Rm_PolicyValidInstTree));
+}
+
 /* FUNCTION PURPOSE: Creates a new valid instance tree node
  ***********************************************************************
  * DESCRIPTION: Creates a new valid instance tree node with the
@@ -153,13 +241,62 @@ int rmPolicyValidInstNodeCompare(Rm_PolicyValidInstNode *node1, Rm_PolicyValidIn
     return(strncmp(node1->name, node2->name, RM_NAME_MAX_CHARS));
 }
 
+/* FUNCTION PURPOSE: Invalidates a valid instance tree node
+ ***********************************************************************
+ * DESCRIPTION: Uses RM OSAL layer to invalidate the specified
+ *              valid instance tree node.
+ */
+void rmPolicyValidInstNodeInv(Rm_PolicyValidInstNode *node)
+{
+    Rm_osalBeginMemAccess((void *)node, sizeof(Rm_PolicyValidInstNode));
+}
+
 /* Generate the valid instance tree manipulation functions */
-RB_GENERATE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, rmPolicyValidInstNodeCompare);
+RB_GENERATE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, rmPolicyValidInstNodeCompare, rmPolicyValidInstNodeInv);
 
 /**********************************************************************
  ***************** Allocator Resource Tree Functions ******************
  **********************************************************************/
 
+/* FUNCTION PURPOSE: Invalidates an entire resource tree
+ ***********************************************************************
+ * DESCRIPTION: Uses the cache handling versions of the RB tree
+ *              macros to walk an entire resource tree and invalidate
+ *              it.
+ */
+void rmResourceTreeInv(Rm_ResourceTree *treeRoot)
+{
+    Rm_ResourceNode *node;
+
+    /* Invalidate the tree root */
+    Rm_osalBeginMemAccess((void *)treeRoot, sizeof(Rm_ResourceTree));
+    /* Walk the tree which will invalidate each element in the tree */
+    node = RB_MIN_CACHED(_Rm_AllocatorResourceTree, treeRoot);
+    while (node) {
+        node = RB_NEXT_CACHED(_Rm_AllocatorResourceTree, treeRoot, node);
+    }
+}
+
+/* FUNCTION PURPOSE: Writebacks an entire resource tree
+ ***********************************************************************
+ * DESCRIPTION: Walks the entire resource tree writing back
+ *              each element to shared memory
+ */
+void rmResourceTreeWb(Rm_ResourceTree *treeRoot)
+{
+    Rm_ResourceNode *node;
+
+    /* Writeback each element in the tree */
+    node = RB_MIN(_Rm_AllocatorResourceTree, treeRoot);
+    do {
+        Rm_osalEndMemAccess((void *)node, sizeof(Rm_ResourceNode));
+        node = RB_NEXT(_Rm_AllocatorResourceTree, treeRoot, node);
+    } while (node);
+
+    /* Writeback the tree root */
+    Rm_osalEndMemAccess((void *)treeRoot, sizeof(Rm_ResourceTree));
+}
+
 /* FUNCTION PURPOSE: Creates a new resource tree node
  ***********************************************************************
  * DESCRIPTION: Creates a new resource tree node with the
@@ -222,6 +359,16 @@ int rmResourceNodeCompare(Rm_ResourceNode *node1, Rm_ResourceNode *node2)
     }
 }
 
+/* FUNCTION PURPOSE: Invalidates a resource tree node
+ ***********************************************************************
+ * DESCRIPTION: Uses RM OSAL layer to invalidate the specified
+ *              resource tree node.
+ */
+void rmResourceNodeInv(Rm_ResourceNode *node)
+{
+    Rm_osalBeginMemAccess((void *)node, sizeof(Rm_ResourceNode));
+}
+
 /* Generate the resource tree manipulation functions */
-RB_GENERATE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, rmResourceNodeCompare)
+RB_GENERATE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, rmResourceNodeCompare, rmResourceNodeInv)
 
index 291608c4a47f1b119339432a1929447eb5438bac..7302871081d0dfb1a004ee624edb0735e86592f8 100644 (file)
@@ -95,6 +95,55 @@ void Osal_rmFree (void *ptr, uint32_t size)
        Memory_free(NULL, ptr, size);
 }
 
+/* FUNCTION PURPOSE: Critical section enter
+ ***********************************************************************
+ * DESCRIPTION: The function is used to enter a critical section.
+ *              Function protects against 
+ *      
+ *              access from multiple cores 
+ *              and 
+ *              access from multiple threads on single core
+ */  
+void *Osal_rmCsEnter(void)
+{
+
+    return NULL;
+}
+
+/* FUNCTION PURPOSE: Critical section exit
+ ***********************************************************************
+ * DESCRIPTION: The function is used to exit a critical section 
+ *              protected using Osal_cppiCsEnter() API.
+ */  
+void Osal_rmCsExit(void *CsHandle)
+{
+
+}
+
+/* FUNCTION PURPOSE: Critical section exit
+ ***********************************************************************
+ * DESCRIPTION: The function is used to indicate that a block of memory is 
+ *              about to be accessed. If the memory block is cached then this 
+ *              indicates that the application would need to ensure that the 
+ *              cache is updated with the data from the actual memory.
+ */  
+void Osal_rmBeginMemAccess(void *ptr, uint32_t size)
+{
+
+}
+
+/* FUNCTION PURPOSE: Critical section exit
+ ***********************************************************************
+ * DESCRIPTION: The function is used to indicate that the block of memory has 
+ *              finished being accessed. If the memory block is cached then the 
+ *              application would need to ensure that the contents of the cache 
+ *              are updated immediately to the actual memory. 
+ */  
+void Osal_rmEndMemAccess(void *ptr, uint32_t size)
+{
+
+}
+
 /* FUNCTION PURPOSE: Creates a task blocking object
  ***********************************************************************
  * DESCRIPTION: The function is used to create a task blocking object
index 5f9fafc1a58ee789701cb3757165d7b376319f71..bd8becc408e700e3cff07eeb30f465c832c2a772 100644 (file)
@@ -58,7 +58,6 @@
 #include <ti/sysbios/family/c64p/Hwi.h>
 
 /* CSL Includes */
-#include <ti/csl/csl_semAux.h>
 #include <ti/csl/csl_cacheAux.h>
 #include <ti/csl/csl_xmcAux.h>
 
@@ -144,9 +143,6 @@ extern const char rmGlobalPolicy[];
 /* RM test Static Policy provided to RM Client Delegate and Client */
 extern const char rmStaticPolicy[];
 
-/* OSAL RM Local Gate Initialization. */
-extern void Osal_rmLocalGateInit (void);
-
 /**********************************************************************
  ********************** Global Variables ******************************
  **********************************************************************/
index 80d0f53813442514d8861d9a152c34f6c7708c65..8ada42d2f9c1082b1676b652a9d9233583ef0fbf 100644 (file)
@@ -3,6 +3,9 @@
  * Copyright 2002 Niels Provos <provos@citi.umich.edu>
  * All rights reserved.
  *
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/ 
+ * ALL RIGHTS RESERVED
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -53,6 +56,9 @@
  * Every operation on a red-black tree is bounded as O(lg n).
  * The maximum height of a red-black tree is 2lg (n+1).
  */
+/* Change Log
+ * TI - Added versions of some RB macros that handle caching
+ */
 
 #define SPLAY_HEAD(name, type)                                         \
 struct name {                                                          \
@@ -373,11 +379,11 @@ struct {                                                          \
 } while (0)
 
 /* Generates prototypes and inline functions */
-#define        RB_PROTOTYPE(name, type, field, cmp)                            \
-       RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
-#define        RB_PROTOTYPE_STATIC(name, type, field, cmp)                     \
-       RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
-#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)            \
+#define        RB_PROTOTYPE(name, type, field, cmp, inv)                               \
+       RB_PROTOTYPE_INTERNAL(name, type, field, cmp, inv,)
+#define        RB_PROTOTYPE_STATIC(name, type, field, cmp, inv)                        \
+       RB_PROTOTYPE_INTERNAL(name, type, field, cmp, inv, __attribute__((__unused__)) static)
+#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, inv, attr)               \
 attr void name##_RB_INSERT_COLOR(struct name *, struct type *);                \
 attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
 attr struct type *name##_RB_REMOVE(struct name *, struct type *);      \
@@ -387,16 +393,18 @@ attr struct type *name##_RB_NFIND(struct name *, struct type *);  \
 attr struct type *name##_RB_NEXT(struct type *);                       \
 attr struct type *name##_RB_PREV(struct type *);                       \
 attr struct type *name##_RB_MINMAX(struct name *, int);                        \
+attr struct type *name##_RB_NEXT_CACHED(struct type *);            \
+attr struct type *name##_RB_MINMAX_CACHED(struct name *, int);         \
                                                                        \
 
 /* Main rb operation.
  * Moves node close to the key of elm to top
  */
-#define        RB_GENERATE(name, type, field, cmp)                             \
-       RB_GENERATE_INTERNAL(name, type, field, cmp,)
-#define        RB_GENERATE_STATIC(name, type, field, cmp)                      \
-       RB_GENERATE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
-#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr)             \
+#define        RB_GENERATE(name, type, field, cmp, inv)                                \
+       RB_GENERATE_INTERNAL(name, type, field, cmp, inv,)
+#define        RB_GENERATE_STATIC(name, type, field, cmp, inv)                 \
+       RB_GENERATE_INTERNAL(name, type, field, cmp, inv, __attribute__((__unused__)) static)
+#define RB_GENERATE_INTERNAL(name, type, field, cmp, inv, attr)                \
 attr void                                                              \
 name##_RB_INSERT_COLOR(struct name *head, struct type *elm)            \
 {                                                                      \
@@ -711,7 +719,52 @@ name##_RB_MINMAX(struct name *head, int val)                               \
                        tmp = RB_RIGHT(tmp, field);                     \
        }                                                               \
        return (parent);                                                \
-}
+}                                   \
+                                                                               \
+/* ARGSUSED */                                                         \
+attr struct type *                                                     \
+name##_RB_NEXT_CACHED(struct type *elm)                                        \
+{                                                                      \
+    inv(elm);                               \
+       if (RB_RIGHT(elm, field)) {                                     \
+               elm = RB_RIGHT(elm, field);                             \
+               inv(elm);                               \
+               while (RB_LEFT(elm, field)) {                           \
+                       elm = RB_LEFT(elm, field);                      \
+                       inv(elm);                               \
+               }                                       \
+       } else {                                                        \
+           inv(RB_PARENT(elm, field));            \
+               if (RB_PARENT(elm, field) &&                            \
+                   (elm == RB_LEFT(RB_PARENT(elm, field), field)))     \
+                       elm = RB_PARENT(elm, field);                    \
+               else {                                                  \
+                       while (RB_PARENT(elm, field) &&                 \
+                           (elm == RB_RIGHT(RB_PARENT(elm, field), field))) {\
+                               elm = RB_PARENT(elm, field);            \
+                               inv(RB_PARENT(elm, field));                      \
+                       }                                       \
+                       elm = RB_PARENT(elm, field);                    \
+               }                                                       \
+       }                                                               \
+       return (elm);                                                   \
+}                                                                      \
+                                                                       \
+attr struct type *                                                     \
+name##_RB_MINMAX_CACHED(struct name *head, int val)                            \
+{                                                                      \
+       struct type *tmp = RB_ROOT(head);                               \
+       struct type *parent = NULL;                                     \
+       while (tmp) {                                                   \
+               parent = tmp;                                           \
+               inv(tmp);                               \
+               if (val < 0)                                            \
+                       tmp = RB_LEFT(tmp, field);                      \
+               else                                                    \
+                       tmp = RB_RIGHT(tmp, field);                     \
+       }                                                               \
+       return (parent);                                                \
+}                                                                      
 
 #define RB_NEGINF      -1
 #define RB_INF 1
@@ -724,6 +777,9 @@ name##_RB_MINMAX(struct name *head, int val)                                \
 #define RB_PREV(name, x, y)    name##_RB_PREV(y)
 #define RB_MIN(name, x)                name##_RB_MINMAX(x, RB_NEGINF)
 #define RB_MAX(name, x)                name##_RB_MINMAX(x, RB_INF)
+/* Cache versions */
+#define RB_NEXT_CACHED(name, x, y)     name##_RB_NEXT_CACHED(y)
+#define RB_MIN_CACHED(name, x)         name##_RB_MINMAX_CACHED(x, RB_NEGINF)
 
 #define RB_FOREACH(x, name, head)                                      \
        for ((x) = RB_MIN(name, head);                                  \