Wrote integer allocator creator
authorJustin Sobota <jsobota@ti.com>
Tue, 4 Dec 2012 23:09:00 +0000 (18:09 -0500)
committerJustin Sobota <jsobota@ti.com>
Tue, 4 Dec 2012 23:09:00 +0000 (18:09 -0500)
device/resources2.dtb
device/tci6614-global-policy.dts
include/rm_dtb_utilloc.h
include/rm_loc.h
include/rm_nameserverloc.h
rm.h
src/rm.c
src/rm_dtb_util.c
src/rm_nameserver.c
test/rm_test.cfg

index 43ee8c710b0aa86bf616f5e4abf5b57681bbc6cb..30801478c1a665eb63457ba43e9729d7d1cb6848 100644 (file)
Binary files a/device/resources2.dtb and b/device/resources2.dtb differ
index 6ff1de2c88c9d3b7541ea0a64ecdc7fe091dfe9a..7f5c9acf9bb5d96885adb741d30e1972657f8251 100644 (file)
@@ -9,11 +9,9 @@
     unrestricted {
         /* System resources with resource-name that matches a resource name
          * provided in both the global device list and by components
-         * utilizing RM */
+         * utilizing RM.  The resource node name must match a resource node name
+         * defined in a component utilizing RM and in the global resource list. */
         timers {  
-            /* resource name property where the name provided must match a 
-             * resource name defined in a component utilizing RM */
-            resource-name = "timers";
             /* assigned range property - defines the range of this resource
              * available to the instance node.
              * The format is <base num> - base = the first value in the range
         };
            qmss {
                qmss-gp-queues {
-                   resource-name = "general-queues";
                    assigned-ranges = <0 2000>;
                    allocation-sizes = <32>;
                };
                qmss-accum-queues {
-                   resource-name = "accumulator-queues";
                    assigned-ranges = <4000 32>;
                    allocation-sizes = <1>;
                };
     };
 
     /* Format for assigning resources to specific RM instances */
-    rm-inst0 {  
-        /* instance-name must match the instName provided to the Rm_init
-         * API when creating the RM instance */
-        instance-name = "RM_Server";  
 
+       /* instance node name must match an instName provided to the Rm_init
+        * API when creating the RM instance */
+    RM_Server {  
         timers {  
-            resource-name = "timers";
             assigned-ranges = <14 15>;
             allocation-sizes = <1>;
         };
            qmss {
                qmss-gp-queues {
-                   resource-name = "general-queues";
                    assigned-range = <2000 1000>;
                    allocation-sizes = <32>;
                };
     };
 
     /* Format for assigning resources to specific RM instances */
-    rm-inst1 {  
-        instance-name = "RM_Client";  
-
+    RM_Client {  
            qmss {
                qmss-gp-queues {
-                   resource-name = "general-queues";
                    assigned-ranges = <3000 1000>;
                    allocation-sizes = <32>;
                };
            };
     };    
 
-    /* Format for assigning resources to specific system tasks */
-    system-task0 {  
-        /* [BIOS-ONLY] task-name must match the taskName provided to BIOS
-         * when creating the task */
-        task-name = "test-task";
-        /* [LINUX-ONLY] task-id must match the PID assigned by Linux when
-         * a task is created */
-     //   task-id = <n>;
-
+    test-task {  
         timers {  
-            resource-name = "timers";
             assigned-ranges = <16>;
             allocation-sizes = <1>;
         };
index 3b5749b625dc64ddba56b19bf5a7a57fa87fad63..82031280d0f27806cd030909cbfb383181cc27d5 100644 (file)
@@ -48,6 +48,20 @@ extern "C" {
  *************Common RM DTB Parsing Defines and Functions**************
  **********************************************************************/
 
+/** 
+* @brief LIBFDT's return codes start at 1.  Map a return value of 0 to an okay result
+*        from the LIBFDT APIs
+*/
+#define RM_DTB_UTIL_RESULT_OKAY 0
+/** 
+* @brief DTB starting node offset for parsing
+*/
+#define RM_DTB_UTIL_STARTING_NODE_OFFSET 0
+/** 
+* @brief DTB starting depth for parsing
+*/
+#define RM_DTB_UTIL_STARTING_DEPTH 0
+
 typedef struct {
     uint32_t base;
     uint32_t length;
@@ -63,14 +77,12 @@ typedef enum {
     Rm_resourcePropType_UNKNOWN = 0,
     /** Resource DTB device name property type */
     Rm_resourcePropType_DEVICE_NAME = 1,    
-    /** Resource DTB resource name property type */
-    Rm_resourcePropType_RESOURCE_NAME = 2,
     /** Resource DTB resource range property type */
-    Rm_resourcePropType_RESOURCE_RANGE = 3,
+    Rm_resourcePropType_RESOURCE_RANGE = 2,
     /** Resource DTB resource allocator property type */
-    Rm_resourcePropType_RESOURCE_ALLOCATOR = 4,
+    Rm_resourcePropType_RESOURCE_ALLOCATOR = 3,
     /** Resource DTB NameServer assignment property type */
-    Rm_resourcePropType_NSASSIGNMENT = 5,    
+    Rm_resourcePropType_NSASSIGNMENT = 4,    
 } Rm_ResourcePropType;
 
 typedef struct {
@@ -82,8 +94,6 @@ typedef struct {
 Rm_ResourcePropType Rm_resourceGetPropertyType(const char *propertyName);
 char *Rm_resourceExtractDeviceName(const void *dtbDataPtr, int32_t dtbDataLen);
 void Rm_resourceFreeDeviceName(char *deviceName);
-char *Rm_resourceExtractResourceName(const void *dtbDataPtr, int32_t dtbDataLen);
-void Rm_resourceFreeResourceName(char *resourceName);
 Rm_ResourceRange *Rm_resourceExtractResourceRange(const void *dtbDataPtr, int32_t dtbDataLen);
 void Rm_resourceFreeResourceRange(Rm_ResourceRange *rangeList);
 char *Rm_resourceExtractResourceAllocator(const void *dtbDataPtr, int32_t dtbDataLen);
@@ -99,17 +109,13 @@ typedef enum {
     /** Policy DTB unknown property type */
     Rm_policyPropType_UNKNOWN = 0,
     /** Policy DTB policy type property type */
-    Rm_policyPropType_POLICY_TYPE = 1,    
-    /** Policy DTB instance name property type */
-    Rm_policyPropType_INSTANCE_NAME = 2,
-    /** Policy DTB resource name property type */
-    Rm_policyPropType_RESOURCE_NAME = 3,    
+    Rm_policyPropType_POLICY_TYPE = 1,      
     /** Policy DTB resource assigned ranges property type */
-    Rm_policyPropType_RESOURCE_ASSIGNED_RANGES = 4,
+    Rm_policyPropType_RESOURCE_ASSIGNED_RANGES = 2,
     /** Policy DTB resource allocation sizes property type */
-    Rm_policyPropType_RESOURCE_ALLOCATION_SIZES = 5,
+    Rm_policyPropType_RESOURCE_ALLOCATION_SIZES = 3,
     /** Policy DTB assigned NameServer names property type */
-    Rm_policyPropType_ASSIGNED_NS_NAMES = 6,    
+    Rm_policyPropType_ASSIGNED_NS_NAMES = 4,    
 } Rm_PolicyPropType;
 
 typedef struct {
@@ -125,8 +131,6 @@ typedef struct {
 Rm_PolicyPropType Rm_policyGetPropertyType(const char *propertyName);
 char *Rm_policyExtractPolicyType(const void *dtbDataPtr, int32_t dtbDataLen);
 void Rm_policyFreePolicyType(char *policyType);
-char *Rm_policyExtractInstanceName(const void *dtbDataPtr, int32_t dtbDataLen);
-void Rm_policyFreeInstanceName(char *instanceName);
 Rm_ResourceRange *Rm_policyExtractResourceAssignedRanges(const void *dtbDataPtr, int32_t dtbDataLen);
 void Rm_policyFreeResourceAssignedRanges(Rm_ResourceRange *rangeList);
 Rm_AllocationSize *Rm_policyExtractAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen);
index e047bf8b43052d71749de22d11d3a907d4aa0579..bebad4543fee3e30ca5a64394746da9931199bb7 100644 (file)
@@ -124,6 +124,9 @@ typedef void *Rm_TransportRouteMap;
 /** Pointer to RM instance's transaction queue */
 typedef void *Rm_TransactionQueue;
 
+/** Pointer to the RM instance's allocators */
+typedef void *Rm_Allocators;
+
 /**
  * @brief RM transaction details values.  Details values provide more fine-grained
  *        information regarding a transaction request or response
@@ -186,11 +189,46 @@ typedef struct {
     void *nextTransaction;    
 } Rm_Transaction;
 
+typedef struct {
+    const void *allocatorData;
+    int32_t allocatorLen;
+    const void *rangeData;
+    int32_t rangeLen;
+    const void *nsAssignData;
+    int32_t nsAssignLen;
+} Rm_ResourceProperties;
+
+typedef enum {
+    Rm_allocatorType_INTEGER = 0,
+    Rm_allocatorType_TREE = 1,
+} Rm_AllocatorType;
+
+typedef struct {
+    uint32_t value;
+    bool allocated;
+    char allocatedTo[RM_INSTANCE_NAME_MAX_CHARS];
+} Rm_IntegerEntry;
+
+typedef struct {
+    uint32_t numResourceElements;
+    Rm_IntegerEntry *resourceArrayBase;
+} Rm_IntegerAllocatorRootEntry;
+
+typedef struct {
+    char resourceName[RM_RESOURCE_NAME_MAX_CHARS];
+    Rm_AllocatorType type;
+    /** Pointer to the first resource entry in the allocator */
+    void *allocatorRootEntry;
+    /** Pointer to next resource allocator */
+    void *nextAllocator;
+} Rm_Allocator;
+
 typedef struct {
     char name[RM_INSTANCE_NAME_MAX_CHARS];
     Rm_InstType instType;
     bool registeredWithDelegateOrServer;
-    Rm_PolicyHandle instPolicy;
+    Rm_PolicyHandle policyDtb;
+    Rm_Allocators allocators;
     /* RM instance transport parameters */
     Rm_TransportRouteMap routeMap;
     /* RM Transaction sequence number counter */
index 2fe9382ed0759c784d93b4d8d10ac6510aff605c..a8f68c10c6198d3cfab521a7fb0e1408e11674d1 100644 (file)
@@ -50,8 +50,11 @@ extern "C" {
 /* RM internal includes */
 #include <ti/drv/rm/include/rm_loc.h>
 
-void Rm_nsAddObject(Rm_Inst *rmInst, Rm_Transaction *transaction);
-void Rm_nsDeleteObject(Rm_Inst *rmInst, Rm_Transaction *transaction);
+#define RM_NS_ACTION_APPROVED 0
+#define RM_NS_ACTION_DENIED -1
+
+int32_t Rm_nsAddObject(Rm_Inst *rmInst, char *objectString, uint32_t objectValue);
+int32_t Rm_nsDeleteObject(Rm_Inst *rmInst, char *objectString);
 
 #ifdef __cplusplus
 }
diff --git a/rm.h b/rm.h
index 29cdba13991a538a5ce8e3e2dcb37dd07fb638a9..69775ea8c6eb7175c9ef4a04e7439a5e96a943a9 100644 (file)
--- a/rm.h
+++ b/rm.h
@@ -184,6 +184,13 @@ typedef struct {
      *  Note: This parameter will be ignored when the instance type is either 
      *  Client Delegate or Client */
     void *globalResourceList;
+    /** [Server Parameter When Running on ARM Linux] Pointer to the Linux DTB.  
+     *  The Linux DTB will be parsed for all tracked resources reserved for use
+     *  by Linux.
+     *  
+     *  Note: This parameter will be ignored when the instance type is either 
+     *  Client Delegate or Client */
+    void *linuxDtb;    
     /** [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 
index 05370e5618d914369460cd598d98ff4169ec53ef..64a9dafa2025076d5dcf36341d9835d33e25be30 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
 Rm_Perms rmQmssPdspFirmwarePerms[RM_ALIGN_PERMISSIONS_ARRAY(RM_QMSS_FIRMWARE_PDSPS, Rm_Perms)];\r
 #endif\r
 \r
+char rmIntegerAllocator[] = "integer";\r
+char rmTreeAllocator[] = "tree";\r
+\r
+extern char rmDtbStartingNode[];\r
+\r
 /** @brief Global Variable which describes the RM Version Information */\r
 const char   rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;\r
 \r
@@ -78,7 +83,6 @@ const char   rmVersionStr[] = RM_VERSION_STR ":" __DATE__  ":" __TIME__;
  ********************** Internal Functions ****************************\r
  **********************************************************************/\r
 \r
-/* At the very least the transaction ID needs to be provided to create a transaction */\r
 Rm_Transaction *Rm_transactionQueueAdd(Rm_Inst *rmInst)\r
 {\r
     Rm_Transaction *transactionQueue = (Rm_Transaction *)rmInst->transactionQueue;\r
@@ -94,40 +98,37 @@ Rm_Transaction *Rm_transactionQueueAdd(Rm_Inst *rmInst)
     /* Return if the memory allocated for the transaction entry is NULL */\r
     if (newTransaction == NULL)\r
     {\r
-        Rm_osalMtCsExit(key);\r
-        return(newTransaction);\r
-    }\r
-\r
-    /* Clear the transaction */\r
-    memset((void *)newTransaction, 0, sizeof(Rm_Transaction));\r
-\r
-    /* Create an ID for the new transaction.  The ID will be used for two purposes:\r
-     * 1) Matching responses from higher level RM agents to requests\r
-     * 2) Provided to the component that requested the service so that it can match its\r
-     *    request with the response it receives via its callback function it provided */\r
-    newTransaction->localId = Rm_transactionGetSequenceNum(rmInst);\r
-    /* New transaction's nextTransaction pointer will always be NULL */\r
-    newTransaction->nextTransaction = NULL;  \r
+        /* Clear the transaction */\r
+        memset((void *)newTransaction, 0, sizeof(Rm_Transaction));\r
+\r
+        /* Create an ID for the new transaction.  The ID will be used for two purposes:\r
+         * 1) Matching responses from higher level RM agents to requests\r
+         * 2) Provided to the component that requested the service so that it can match its\r
+         *    request with the response it receives via its callback function it provided */\r
+        newTransaction->localId = Rm_transactionGetSequenceNum(rmInst);\r
+        /* New transaction's nextTransaction pointer will always be NULL */\r
+        newTransaction->nextTransaction = NULL;  \r
+\r
+        /* Check if there are any transactions in the transaction queue */\r
+        if (transactionQueue)\r
+        {\r
+            /* At least one transaction in the transaction queue.  Add the new entry to the \r
+             * end of the transaction queue */\r
+            while (transactionQueue->nextTransaction != NULL)\r
+            {\r
+                /* Traverse the list until arriving at the last transaction */\r
+                transactionQueue = transactionQueue->nextTransaction;\r
+            }\r
 \r
-    /* Check if there are any transactions in the transaction queue */\r
-    if (transactionQueue)\r
-    {\r
-        /* At least one transaction in the transaction queue.  Add the new entry to the \r
-         * end of the transaction queue */\r
-        while (transactionQueue->nextTransaction != NULL)\r
+            /* Add the new transaction to the end of the queue */\r
+            transactionQueue->nextTransaction = newTransaction;\r
+        }\r
+        else\r
         {\r
-            /* Traverse the list until arriving at the last transaction */\r
-            transactionQueue = transactionQueue->nextTransaction;\r
+            /* The transaction queue does not currently exist.  The new transaction is the \r
+             * first transaction */\r
+            rmInst->transactionQueue = newTransaction;\r
         }\r
-\r
-        /* Add the new transaction to the end of the queue */\r
-        transactionQueue->nextTransaction = newTransaction;\r
-    }\r
-    else\r
-    {\r
-        /* The transaction queue does not currently exist.  The new transaction is the \r
-         * first transaction */\r
-        rmInst->transactionQueue = newTransaction;\r
     }\r
 \r
     Rm_osalMtCsExit(key);\r
@@ -189,11 +190,11 @@ int32_t Rm_transactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
     else\r
     {\r
         /* Delete the transaction */\r
-        if (prevTransaction == NULL)\r
+        if ((prevTransaction == NULL) && transaction->nextTransaction)\r
         {\r
             /* Transaction to be deleted exists at start of transaction queue.  Map second\r
-             * transaction to be start of transaction queue.  This covers case where there is\r
-             * only one transaction in the queue since the nextTransaction will be NULL */\r
+             * transaction to be start of transaction queue as long as there are more than\r
+             * one transactions. */\r
             rmInst->transactionQueue = transaction->nextTransaction;\r
         }\r
         else\r
@@ -303,6 +304,391 @@ void Rm_transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
     Rm_transactionQueueDelete(rmInst, transaction->localId);\r
 }\r
 \r
+Rm_Allocator *Rm_allocatorAdd(Rm_Inst *rmInst, const char *resourceName, Rm_AllocatorType type)\r
+{\r
+    Rm_Allocator *allocators = (Rm_Allocator *)rmInst->allocators;\r
+    Rm_Allocator *newAllocator = NULL;\r
+    void *key;\r
+\r
+    /* Lock access to the RM instance's allocator list */\r
+    key = Rm_osalMtCsEnter();\r
+\r
+    /* Get memory for a new allocator from local memory */\r
+    newAllocator = Rm_osalMalloc(sizeof(Rm_Allocator));\r
+\r
+    /* Return if the memory allocated for the allocator is NULL */\r
+    if (newAllocator != NULL)\r
+    {\r
+        /* Clear the allocator */\r
+        memset((void *)newAllocator, 0, sizeof(Rm_Allocator));\r
+\r
+        /* Populate the allocator */\r
+        newAllocator->type = type;\r
+        strcpy(newAllocator->resourceName, resourceName);\r
+        /* allocator's root entry will be created by the invoking function */\r
+        newAllocator->allocatorRootEntry = NULL;\r
+        /* New allocator's nextAllocator pointer will always be NULL */\r
+        newAllocator->nextAllocator = NULL;  \r
+\r
+        /* Check if there are any allocators in the allocator list */\r
+        if (allocators)\r
+        {\r
+            /* At least one allocator in the allocator list.  Add the new allocator to the \r
+             * end of the allocator list */\r
+            while (allocators->nextAllocator != NULL)\r
+            {\r
+                /* Traverse the list until arriving at the last allocator */\r
+                allocators = allocators->nextAllocator;\r
+            }\r
+\r
+            /* Add the new allocator to the end of the list */\r
+            allocators->nextAllocator = newAllocator;\r
+        }\r
+        else\r
+        {\r
+            /* The allocator list does not currently exist.  The new allocator is the \r
+             * first allocator */\r
+            rmInst->allocators = newAllocator;\r
+        }\r
+    }\r
+\r
+    Rm_osalMtCsExit(key);\r
+    return (newAllocator);\r
+}\r
+\r
+int32_t Rm_allocatorDelete(Rm_Inst *rmInst, char *resourceName)\r
+{\r
+    Rm_Allocator *allocator = (Rm_Allocator *) rmInst->allocators;\r
+    Rm_Allocator *prevAllocator = NULL;\r
+    int32_t retVal = RM_SERVICE_STATE_OKAY;\r
+    void *key;\r
+\r
+    /* Lock access to the RM instance's allocator list */\r
+    key = Rm_osalMtCsEnter();\r
+\r
+    /* Find the resource within the specified RM instance's allocator list. */\r
+    while (allocator != NULL)\r
+    {\r
+        if (strcmp(allocator->resourceName, resourceName) == 0)\r
+        {\r
+            /* Match: break out of loop and delete the transaction */\r
+            break;             \r
+        }\r
+\r
+        prevAllocator = allocator;\r
+        allocator = allocator->nextAllocator;\r
+    }\r
+\r
+    /* Traversed entire list but did not find allocator. */\r
+    if (allocator == NULL)\r
+    {\r
+        retVal = -22; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+    }\r
+    else\r
+    {\r
+        /* Delete the allocator */\r
+        if ((prevAllocator == NULL) && allocator->nextAllocator)\r
+        {\r
+            /* Allocator to be deleted exists at start of allocator list.  Map second\r
+             * allocator to be start of allocator list as long as there are more than\r
+             * one allocators. */\r
+            rmInst->allocators = allocator->nextAllocator;\r
+        }\r
+        else\r
+        {\r
+            /* Allocator to be deleted is in the middle or at end of the list.  Adjust \r
+             * adjacent allocator pointers.  This covers the case where the allocator to be \r
+             * removed is at the end of the list. */\r
+            prevAllocator->nextAllocator = allocator->nextAllocator;\r
+        }\r
+\r
+        /* Free the memory associated with the allocator. */\r
+        Rm_osalFree((void *)allocator, sizeof(Rm_Allocator));\r
+    }\r
+\r
+    Rm_osalMtCsExit(key);\r
+    return (retVal);\r
+}\r
+\r
+int32_t Rm_createIntegerAllocator(Rm_Inst *rmInst, const char *resourceName, Rm_ResourceRange *range)\r
+{\r
+    Rm_Allocator *allocator = NULL;\r
+    Rm_ResourceRange *rangeBasePtr = range;\r
+    Rm_IntegerAllocatorRootEntry *intRootEntry = NULL;\r
+    uint16_t i, entryIndex;\r
+\r
+    /* Create the new base integer allocator */\r
+    allocator = Rm_allocatorAdd(rmInst, resourceName, Rm_allocatorType_INTEGER);\r
+\r
+    /* Construct the integer allocator root entry */\r
+    intRootEntry = Rm_osalMalloc(sizeof(Rm_IntegerAllocatorRootEntry));\r
+    intRootEntry->numResourceElements = 0;\r
+\r
+    /* Get the number of entries to allocate based on the lengths in the ranges */\r
+    while (range != NULL)\r
+    {\r
+        intRootEntry->numResourceElements += range->length;\r
+        range = range->nextRange;\r
+    }\r
+\r
+    /* Initialize the entries using the range information */\r
+    if (intRootEntry->numResourceElements)\r
+    {\r
+        intRootEntry->resourceArrayBase = Rm_osalMalloc(sizeof(Rm_IntegerEntry) * intRootEntry->numResourceElements);\r
+        memset((void *)intRootEntry->resourceArrayBase, 0, sizeof(Rm_IntegerEntry) * intRootEntry->numResourceElements);\r
+\r
+        /* Reset the range pointer */\r
+        range = rangeBasePtr;\r
+        entryIndex = 0;\r
+\r
+        while (range != NULL)\r
+        {\r
+            /* Initialize each entry */\r
+            for (i = range->base; i < (range->base + range->length); i++, entryIndex++)\r
+            {\r
+                intRootEntry->resourceArrayBase[entryIndex].value = i;\r
+            }\r
+            \r
+            range = range->nextRange;\r
+        }\r
+        \r
+        allocator->allocatorRootEntry = intRootEntry;\r
+    }\r
+    else\r
+    {\r
+        /* No resource entries were created.  Free the memory associated with the\r
+         * allocator and the root entry */\r
+        Rm_osalFree((void *)intRootEntry, sizeof(Rm_IntegerAllocatorRootEntry));\r
+        Rm_allocatorDelete(rmInst, allocator->resourceName);\r
+    }\r
+\r
+    return(0);  /* TODO: FIX THIS RETURN */\r
+}\r
+\r
+int32_t Rm_createAndInitAllocator(Rm_Inst *rmInst, const char *resourceName, \r
+                                  Rm_ResourceProperties *resourceProperties)\r
+{\r
+    char *allocatorType = NULL;\r
+    Rm_ResourceRange *range = NULL;\r
+    Rm_ResourceRange *rangeBasePtr = NULL;\r
+    Rm_NsAssignment *nsAssignments = NULL;\r
+    Rm_NsAssignment *nsAssignmentBasePtr = NULL;\r
+    int32_t retVal = RM_DTB_UTIL_RESULT_OKAY;\r
+\r
+    /* TODO: NEED CHECKS FOR VALIDITY OF ALL THE resourceProperties FIELDS */\r
+\r
+    /* Extract the resource properties from the DTB */\r
+    allocatorType = Rm_resourceExtractResourceAllocator(resourceProperties->allocatorData, \r
+                                                        resourceProperties->allocatorLen);\r
+    range = rangeBasePtr = Rm_resourceExtractResourceRange(resourceProperties->rangeData, \r
+                                                           resourceProperties->rangeLen);\r
+\r
+    /* Create an allocator based on the allocator type specified */\r
+    if (strcmp(allocatorType, &rmIntegerAllocator[0]) == 0)\r
+    {\r
+        /* Create an integer allocator using the resource properties */\r
+        retVal = Rm_createIntegerAllocator(rmInst, resourceName, range);        \r
+    }\r
+    else if (strcmp(allocatorType, &rmTreeAllocator[0]) == 0)\r
+    {\r
+        /* Create a tree allocator using the resource properties */\r
+    }\r
+    else\r
+    {\r
+        /* Allocator type not recognized.  Free the resource properties and return */\r
+        retVal = -21; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+    }\r
+    \r
+    if (retVal >= RM_DTB_UTIL_RESULT_OKAY)\r
+    {\r
+        /* Create entries in the NameServer if any NameServer assignments were specified */\r
+        if (resourceProperties->nsAssignData && resourceProperties->nsAssignLen)\r
+        {\r
+            nsAssignments = Rm_resourceExtractNsAssignment(resourceProperties->nsAssignData, \r
+                                                           resourceProperties->nsAssignLen);\r
+\r
+            /* Cycle through the list of assignments and add them to the NameServer */\r
+            nsAssignmentBasePtr = nsAssignments;\r
+            while (nsAssignments)\r
+            {\r
+                /* TODO: RETURN IF ANY OF THE ADDS FAIL??? */\r
+                Rm_nsAddObject(rmInst, nsAssignments->nsName, nsAssignments->resourceValue);\r
+                nsAssignments = nsAssignments->nextNsAssignment;\r
+            }\r
+            /* Free the memory allocated for the NameServer assignments */\r
+            Rm_resourceFreeNsAssignmentList(nsAssignmentBasePtr);\r
+        }\r
+    }\r
+\r
+    /* Free the memory allocated for the resource properties */\r
+    Rm_resourceFreeResourceAllocator(allocatorType);\r
+    Rm_resourceFreeResourceRange(rangeBasePtr);\r
+\r
+    return(retVal);\r
+}\r
+\r
+int32_t Rm_parseResourceProperty(void *globalResourceDtb, int32_t offset, Rm_ResourceProperties *propertyInfo)\r
+{\r
+       int32_t propertyLen;\r
+       const char *propertyName;\r
+       const void *propertyData;\r
+    Rm_ResourcePropType propertyType;\r
+    int32_t retVal = RM_DTB_UTIL_RESULT_OKAY;\r
+\r
+    /* Get the property data and store it in the corresponding propertyInfo field */\r
+       propertyData = fdt_getprop_by_offset(globalResourceDtb, offset, &propertyName, &propertyLen);\r
+    if (propertyData)\r
+    {\r
+        propertyType = Rm_resourceGetPropertyType(propertyName);\r
+        if (propertyType == Rm_resourcePropType_RESOURCE_ALLOCATOR)\r
+        {\r
+            if (propertyInfo->allocatorData || propertyInfo->allocatorLen)\r
+            {\r
+                /* The allocator fields have already been populated.  Return an error.\r
+                 * The resource list has specified a property field more than once\r
+                 * for a resource node */\r
+                retVal = -17; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+            }\r
+            else\r
+            {\r
+                propertyInfo->allocatorData = propertyData;\r
+                propertyInfo->allocatorLen = propertyLen;\r
+            }\r
+        }\r
+        else if (propertyType == Rm_resourcePropType_RESOURCE_RANGE)\r
+        {\r
+            if (propertyInfo->rangeData || propertyInfo->rangeLen)\r
+            {\r
+                /* The range fields have already been populated.  Return an error.\r
+                 * The resource list has specified a property field more than once\r
+                 * for a resource node */\r
+                retVal = -18; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+            }\r
+            else\r
+            {\r
+                propertyInfo->rangeData = propertyData;\r
+                propertyInfo->rangeLen = propertyLen;\r
+            }\r
+        }\r
+        else if (propertyType == Rm_resourcePropType_NSASSIGNMENT)\r
+        {\r
+            if (propertyInfo->nsAssignData || propertyInfo->nsAssignLen)\r
+            {\r
+                /* The nsAssign fields have already been populated.  Return an error.\r
+                 * The resource list has specified a property field more than once\r
+                 * for a resource node */\r
+                retVal = -19; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+            }\r
+            else\r
+            {\r
+                propertyInfo->nsAssignData = propertyData;\r
+                propertyInfo->nsAssignLen = propertyLen;\r
+            }\r
+        }\r
+        else\r
+        {\r
+            retVal = -20; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+        }\r
+    }\r
+    else\r
+    {\r
+        retVal = -16; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+    }\r
+\r
+    /* Don't get anymore properties if error occurred */\r
+    if (retVal == RM_DTB_UTIL_RESULT_OKAY)\r
+    {\r
+        offset = fdt_next_property_offset(globalResourceDtb, offset);\r
+       if (offset >= 0)\r
+       {\r
+           retVal = Rm_parseResourceProperty(globalResourceDtb, offset, propertyInfo);\r
+       }\r
+        else if (offset != -FDT_ERR_NOTFOUND)\r
+        {\r
+            /* Error was returned by LIBFDT when parsing the properties */\r
+            retVal = offset;\r
+        }\r
+    }\r
+    \r
+    return (retVal);\r
+}\r
+\r
+int32_t Rm_parseResourceNode(Rm_Inst *rmInst, void *globalResourceDtb, int32_t nodeOffset, int32_t depth)\r
+{\r
+       const char *resourceName = fdt_get_name(globalResourceDtb, nodeOffset, NULL);\r
+    Rm_ResourceProperties resourceProperties;\r
+       int32_t error = RM_DTB_UTIL_RESULT_OKAY;\r
+       int32_t offset;\r
+\r
+    /* Initialize the resource properties structure */\r
+    memset((void *)&resourceProperties, 0, sizeof(Rm_ResourceProperties));\r
+\r
+    /* Ignore properties of the base node */\r
+    if (strcmp(resourceName, rmDtbStartingNode))\r
+    {\r
+        /* Get the properties for the resource node if any exist */\r
+       offset = fdt_first_property_offset(globalResourceDtb, nodeOffset);\r
+       if (offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET)\r
+       {\r
+            /* Since at least one property exists attempt to parse the property nodes and \r
+             * use them to create and initialize a resource allocator */\r
+               error =  Rm_parseResourceProperty(globalResourceDtb, offset, &resourceProperties);\r
+            if (error < -FDT_ERR_NOTFOUND)\r
+            {\r
+                return (error);\r
+            }\r
+            \r
+            /* Initialize an allocator with the resource properties if no error was returned */\r
+            Rm_createAndInitAllocator(rmInst, resourceName, &resourceProperties);\r
+       }\r
+        else if (offset != -FDT_ERR_NOTFOUND)\r
+        {\r
+               /* Error was returned by LIBFDT when parsing the properties */\r
+            return (offset);\r
+        }\r
+    }\r
+    \r
+    /* Get the next resource node */\r
+       offset = fdt_next_node(globalResourceDtb, nodeOffset, &depth);\r
+    /* Check the offset and depth of the next node to make sure the current node\r
+     * wasn't the last node in the Resource List.  A depth less than the depth set\r
+     * at the start of the recursion will signal the end of the resource list */\r
+    if ((offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) && (depth >= RM_DTB_UTIL_STARTING_DEPTH))\r
+    {\r
+        error = Rm_parseResourceNode(rmInst, globalResourceDtb, offset, depth);\r
+        if (error < -FDT_ERR_NOTFOUND)\r
+        {\r
+            return (error);\r
+        }\r
+    }\r
+    else if (offset != -FDT_ERR_NOTFOUND)\r
+    {\r
+        /* Error was returned by LIBFDT when parsing the nodes */\r
+        return (offset);\r
+    }\r
+\r
+    return (RM_DTB_UTIL_RESULT_OKAY);\r
+}\r
+\r
+int32_t Rm_initializeAllocators(Rm_Inst *rmInst, void *globalResourceDtb)\r
+{\r
+    int32_t nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;\r
+    int32_t startDepth = RM_DTB_UTIL_STARTING_DEPTH;\r
+    int32_t result = RM_DTB_UTIL_RESULT_OKAY;\r
+\r
+    /* Recursively parse the Global Resource List, creating an allocator for\r
+     * each resource as specified in the node */\r
+    result = Rm_parseResourceNode(rmInst, globalResourceDtb, nodeOffset, startDepth);\r
+\r
+    return(result);\r
+}\r
+         \r
+int32_t Rm_reserveLinuxResources(void *linuxResourceDtb)\r
+{\r
+    return(0);\r
+\r
+}\r
+\r
 void Rm_allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
     if (rmInst->instType == Rm_instType_CLIENT_DELEGATE)\r
@@ -614,13 +1000,31 @@ void Rm_transactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)
                     {\r
                         /* Create a new NameServer object with the request transaction information.\r
                          * Transaction will contain the state result of the NameServer addition. */\r
-                        Rm_nsAddObject(rmInst, transaction);\r
+                        if (Rm_nsAddObject(rmInst, transaction->resourceInfo.nsName,\r
+                                           transaction->resourceInfo.base) == RM_NS_ACTION_APPROVED)\r
+                        {\r
+                            transaction->state = RM_SERVICE_APPROVED;\r
+                        }\r
+                        else\r
+                        {\r
+                            /* TEMP: UPDATE THIS STATE VALUE */\r
+                            transaction->state = RM_SERVICE_DENIED_BEGIN;\r
+                        }\r
                     }\r
                     else\r
                     {\r
                         /* Delete an existing NameServer object with the request transaction information\r
                          * Transaction will contain the state result of the NameServer addition. */\r
-                        Rm_nsDeleteObject(rmInst, transaction);\r
+                        if (Rm_nsDeleteObject(rmInst, transaction->resourceInfo.nsName) == \r
+                            RM_NS_ACTION_APPROVED)\r
+                        {\r
+                            transaction->state = RM_SERVICE_APPROVED;\r
+                        }\r
+                        else\r
+                        {\r
+                            /* TEMP: UPDATE THIS STATE VALUE */\r
+                            transaction->state = RM_SERVICE_DENIED_BEGIN;\r
+                        }\r
                     }\r
 \r
                     /* If source instance name does not match the local instance\r
@@ -642,107 +1046,6 @@ void Rm_transactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)
     }\r
 }\r
 \r
-void get_property(void *fdt, int32_t offset)\r
-{\r
-       int32_t len;\r
-       const char *name;\r
-    char *resourceName, *allocator;\r
-       const void *data;\r
-    Rm_ResourceRange *range = NULL;\r
-    Rm_ResourceRange *startOfRange = NULL;\r
-    Rm_NsAssignment *nsAssignment = NULL;\r
-    Rm_NsAssignment *startOfNsAssignment = NULL;\r
-    Rm_ResourcePropType propType;\r
-\r
-       data = fdt_getprop_by_offset(fdt, offset, &name, &len);\r
-    if (!data)\r
-        Rm_osalLog("Error traverse_properties fdt_getprop_by_offset: %d\n", len);\r
-    else\r
-    {\r
-        Rm_osalLog("Property name: %s with length: %d offset: %d and address: %x\n", name, len, offset, data);\r
-\r
-        propType = Rm_resourceGetPropertyType(name);\r
-        if (propType == Rm_resourcePropType_RESOURCE_NAME)\r
-        {\r
-            Rm_osalLog("Resource Name: %s\n", resourceName = Rm_resourceExtractResourceName(data, len));\r
-            Rm_resourceFreeResourceName(resourceName);\r
-        }\r
-        else if (propType == Rm_resourcePropType_RESOURCE_RANGE)\r
-        {\r
-            startOfRange = range = Rm_resourceExtractResourceRange(data, len);\r
-            while (range != NULL)\r
-            {\r
-                Rm_osalLog("Resource base: %d and length: %d\n", range->base, range->length);\r
-                range = (Rm_ResourceRange *) range->nextRange;\r
-            }\r
-            Rm_resourceFreeResourceRange(startOfRange);\r
-        }\r
-        else if (propType == Rm_resourcePropType_NSASSIGNMENT)\r
-        {\r
-            startOfNsAssignment = nsAssignment = Rm_resourceExtractNsAssignment(data, len);\r
-            while (nsAssignment != NULL)\r
-            {\r
-                Rm_osalLog("NameServer assignment name: %s and value: %d\n", nsAssignment->nsName, nsAssignment->resourceValue);\r
-                nsAssignment = (Rm_NsAssignment *) nsAssignment->nextNsAssignment;\r
-            }\r
-            Rm_resourceFreeNsAssignmentList(startOfNsAssignment);\r
-        }   \r
-        else if (propType == Rm_resourcePropType_RESOURCE_ALLOCATOR)\r
-        {\r
-            Rm_osalLog("Resource Allocator: %s\n", allocator = Rm_resourceExtractResourceAllocator(data, len));\r
-            Rm_resourceFreeResourceAllocator(allocator);\r
-        }\r
-    }\r
-\r
-       offset = fdt_next_property_offset(fdt, offset);\r
-       if (offset >= 0)\r
-               get_property(fdt, offset);\r
-       else if (offset != -FDT_ERR_NOTFOUND)\r
-               Rm_osalLog("Error traverse_properties fdt_next_property_offset: %d\n", offset);\r
-}\r
-\r
-void get_node(void *fdt, int32_t nodeOffset, int32_t depth)\r
-{\r
-       const char *nodeName = fdt_get_name(fdt, nodeOffset, NULL);\r
-       char path[256];\r
-       int32_t error;\r
-       int32_t offset;\r
-\r
-       error = fdt_get_path(fdt, nodeOffset, path, sizeof(path));\r
-    if (error)\r
-        Rm_osalLog("Error traverse_node fdt_get_path: %d\n", error);\r
-    else\r
-        Rm_osalLog("Node path: %s with name %s\n", path, nodeName);\r
-\r
-    /* Get the properties for the node if any exist */\r
-       offset = fdt_first_property_offset(fdt, nodeOffset);\r
-       if (offset >= 0)\r
-               get_property(fdt, offset);\r
-       else if (offset != -FDT_ERR_NOTFOUND)\r
-               Rm_osalLog("Error traverse_node fdt_first_property_offset: %d\n", offset);\r
-\r
-    /* Get the next node */\r
-       offset = fdt_next_node(fdt, nodeOffset, &depth);\r
-    if ((offset >= 0) && (depth >= 0))\r
-    {\r
-        Rm_osalLog("Next node offset: %d with depth: %d\n", offset, depth);\r
-        get_node(fdt, offset, depth);\r
-    }\r
-    else if (offset < 0)\r
-        Rm_osalLog("Error traverse_node fdt_next_node: %d\n", offset);\r
-\r
-    Rm_osalLog("Last node offset: %d and depth: %d\n", offset, depth);\r
-}\r
-\r
-void traverseFdt (void *fdt)\r
-{\r
-    int32_t nodeOffset = 0;  /* offset starts at 0, beginning of tree */\r
-    int32_t startDepth = 0;  /* depth starts at 0, beginning of tree */\r
-\r
-    get_node(fdt, nodeOffset, startDepth);\r
-}\r
-\r
-\r
 /**********************************************************************\r
  ********************** Application visible APIs **********************\r
  **********************************************************************/\r
@@ -750,7 +1053,8 @@ void traverseFdt (void *fdt)
 Rm_Handle Rm_init(Rm_InitCfg *initCfg)\r
 {\r
     Rm_Inst *rmInst;\r
-    void *fdt = initCfg->globalResourceList;  \r
+    void *globalResourceDtb = NULL;\r
+    void *linuxResourceDtb = NULL;\r
 \r
     /* Instance creation checks.  Add one to strlen calculation for null character */\r
     if ((strlen(initCfg->instName) + 1) > RM_INSTANCE_NAME_MAX_CHARS)\r
@@ -765,11 +1069,18 @@ Rm_Handle Rm_init(Rm_InitCfg *initCfg)
     strcpy (&rmInst->name[0], initCfg->instName);\r
     rmInst->instType = initCfg->instType;\r
     rmInst->registeredWithDelegateOrServer = false;\r
+    rmInst->policyDtb = NULL;\r
 \r
     /* Initialize the transport routing map linked list pointer to NULL.  The linked list\r
      * nodes will be created when the application registers transports */\r
     rmInst->routeMap = NULL;\r
 \r
+    /* Initialize the allocators linked list pointer to NULL.  The linked list nodes will\r
+     * be created on the Server instance when the application reads in the resource list.\r
+     * Nodes will also be created on Client Delegates when blocks of resources are requested\r
+     * for allocation to clients. */\r
+    rmInst->allocators = NULL;\r
+\r
     /* Initialize the transaction queue elements. */\r
     rmInst->transactionSeqNum = Rm_transactionInitSequenceNum();\r
     rmInst->transactionQueue= NULL;\r
@@ -777,17 +1088,33 @@ Rm_Handle Rm_init(Rm_InitCfg *initCfg)
     /* RM Server specific actions */\r
     if (rmInst->instType == Rm_instType_SERVER)\r
     {\r
-        /* Open the ResourceList file */\r
-        fdt_open_into(initCfg->globalResourceList, fdt, fdt_totalsize(initCfg->globalResourceList));\r
+        /* Open the ResourceList file and provide it to the resource initializer. */\r
+        if (initCfg->globalResourceList)\r
+        {\r
+            globalResourceDtb = initCfg->globalResourceList;\r
+            fdt_open_into(globalResourceDtb, globalResourceDtb, fdt_totalsize(globalResourceDtb));            \r
+            Rm_initializeAllocators(rmInst, globalResourceDtb);\r
+        }\r
 \r
-        /* TEST: Try to parse the entire fdt */\r
-        traverseFdt(fdt);\r
+        /* Parse the Linux DTB for the resources reserved by the Linux kernel.  These resources\r
+         * will be marked as used in the resource allocators. */\r
+        if (initCfg->linuxDtb)\r
+        {\r
+            linuxResourceDtb = initCfg->linuxDtb;\r
+            fdt_open_into(linuxResourceDtb, linuxResourceDtb, fdt_totalsize(linuxResourceDtb));            \r
+            Rm_reserveLinuxResources(linuxResourceDtb);\r
+        }\r
     }\r
 \r
     /* Instance startup policies are only used for Servers and Client Delegates */\r
     if (rmInst->instType != Rm_instType_CLIENT)\r
     {\r
-        rmInst->instPolicy = initCfg->startupPolicy;\r
+        /* Open the instance's policy and store it */\r
+        if (initCfg->startupPolicy)\r
+        {\r
+            rmInst->policyDtb = initCfg->startupPolicy;\r
+            fdt_open_into(rmInst->policyDtb, rmInst->policyDtb, fdt_totalsize(rmInst->policyDtb));  \r
+        }\r
 \r
         /* Store policy via policy APIs ... */\r
     }\r
index d5bda9389e9a32438882649417e1419a905b7e79..7a0f779a029ff8de71470782146003e09258c299 100644 (file)
@@ -57,6 +57,8 @@
  ********************Common DTB Parsing Functions**********************
  **********************************************************************/
 
+char rmDtbStartingNode[] = "\0";
 char *Rm_commonExtractName(const void *dtbDataPtr, int32_t dtbDataLen)
 {
     char *resourceName = NULL;
@@ -153,7 +155,6 @@ void Rm_commonFreeRangeList(Rm_ResourceRange *rangeList)
  * by an application integrator to define the properties of resources
  * listed in the Device Resource List */
 char rmResourceDeviceNameProp[] = "device-name";
-char rmResourceResourceNameProp[] = "resource-name";
 char rmResourceResourceRangeProp[] = "resource-range";
 char rmResourceResourceAllocatorProp[] = "allocator";
 char rmResourceNsAssignmentProp[] = "ns-assignment";
@@ -166,10 +167,6 @@ Rm_ResourcePropType Rm_resourceGetPropertyType(const char * propertyName)
     {
         propertyType = Rm_resourcePropType_DEVICE_NAME;
     }    
-    else if(strcmp(rmResourceResourceNameProp, propertyName) == 0)
-    {
-        propertyType = Rm_resourcePropType_RESOURCE_NAME;
-    }
     else if(strcmp(rmResourceResourceRangeProp, propertyName) == 0)
     {
         propertyType = Rm_resourcePropType_RESOURCE_RANGE;
@@ -196,16 +193,6 @@ void Rm_resourceFreeDeviceName(char *deviceName)
     Rm_commonFreeName(deviceName);
 }
 
-char *Rm_resourceExtractResourceName(const void *dtbDataPtr, int32_t dtbDataLen)
-{
-    return(Rm_commonExtractName(dtbDataPtr, dtbDataLen));
-}
-
-void Rm_resourceFreeResourceName(char *resourceName)
-{
-    Rm_commonFreeName(resourceName);
-}
-
 Rm_ResourceRange *Rm_resourceExtractResourceRange(const void *dtbDataPtr, int32_t dtbDataLen)
 {
     return(Rm_commonExtractRange(dtbDataPtr, dtbDataLen));
@@ -314,8 +301,6 @@ void Rm_resourceFreeNsAssignmentList (Rm_NsAssignment *nsAssignmentList)
  * by an application integrator to define the properties of resources
  * listed in a Resource Manager Policy */
 char rmPolicyPolicyTypeProp[] = "policy-type";
-char rmPolicyInstanceNameProp[] = "instance-name";
-char rmPolicyResourceNameProp[] = "resource-name";
 char rmPolicyResourceAssignedRangesProp[] = "assigned-ranges";
 char rmPolicyResourceAllocationSizesProp[] = "allocation-sizes";
 char rmPolicyResourceAssignedNsNamesProp[] = "assigned-ns-names";
@@ -328,14 +313,6 @@ Rm_PolicyPropType Rm_policyGetPropertyType(const char * propertyName)
     {
         propertyType = Rm_policyPropType_POLICY_TYPE;
     } 
-    else if(strcmp(rmPolicyInstanceNameProp, propertyName) == 0)
-    {
-        propertyType = Rm_policyPropType_INSTANCE_NAME;
-    }    
-    else if(strcmp(rmPolicyResourceNameProp, propertyName) == 0)
-    {
-        propertyType = Rm_policyPropType_RESOURCE_NAME;
-    }
     else if(strcmp(rmPolicyResourceAssignedRangesProp, propertyName) == 0)
     {
         propertyType = Rm_policyPropType_RESOURCE_ASSIGNED_RANGES;
@@ -363,16 +340,6 @@ void Rm_policyFreePolicyType(char *policyType)
     Rm_commonFreeName(policyType);
 }
 
-char *Rm_policyExtractInstanceName(const void *dtbDataPtr, int32_t dtbDataLen)
-{
-    return(Rm_commonExtractName(dtbDataPtr, dtbDataLen));
-}
-
-void Rm_policyFreeInstanceName(char *instanceName)
-{
-    Rm_commonFreeName(instanceName);
-}
-
 Rm_ResourceRange *Rm_policyExtractResourceAssignedRanges(const void *dtbDataPtr, int32_t dtbDataLen)
 {
     return(Rm_commonExtractRange(dtbDataPtr, dtbDataLen));
index a4ac48618336690bcaa2fd80b076e2c2a6864130..9abbe2b325a95c745c762b0ba459b884c3093f4c 100644 (file)
  ********************** Internal Functions ****************************
  **********************************************************************/
 
-void Rm_nsAddObject(Rm_Inst *rmInst, Rm_Transaction *transaction)
+int32_t Rm_nsAddObject(Rm_Inst *rmInst, char *objectString, uint32_t objectValue)
 {
     /* STUB APPROVED FOR NOW */
-    transaction->state = RM_SERVICE_APPROVED;
+    return(RM_NS_ACTION_APPROVED);
 
 }
 
-void Rm_nsDeleteObject(Rm_Inst *rmInst, Rm_Transaction *transaction)
+int32_t Rm_nsDeleteObject(Rm_Inst *rmInst, char *objectString)
 {
     /* STUB APPROVED FOR NOW */
-    transaction->state = RM_SERVICE_APPROVED;
+    return(RM_NS_ACTION_APPROVED);
 }
 
index 0af281fbf9a2cf185c061c87932596e135e0ae21..d78ad4883ed1b9cff2472f2810761e25b49823eb 100644 (file)
@@ -63,7 +63,7 @@ var MultiProc   = xdc.useModule('ti.sdo.utils.MultiProc');
 
 /* BIOS/XDC modules */
 var BIOS        = xdc.useModule('ti.sysbios.BIOS');
-BIOS.heapSize   = 0x8000;
+BIOS.heapSize   = 0x10000;
 var Task        = xdc.useModule('ti.sysbios.knl.Task');
 
 /* Synchronize all processors (this will be done in Ipc_start) */