summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 96a3a0f)
raw | patch | inline | side by side (parent: 96a3a0f)
| author | Justin Sobota <jsobota@ti.com> | |
| Tue, 29 Jan 2013 21:13:54 +0000 (16:13 -0500) | ||
| committer | Justin Sobota <jsobota@ti.com> | |
| Tue, 29 Jan 2013 21:13:54 +0000 (16:13 -0500) |
33 files changed:
diff --git a/build/buildlib.xs b/build/buildlib.xs
index 555360e8e1f855853fa20c4814b2feedd1d0713f..4934b5a6745894e38b6b67030dcb00a9cb5da3c9 100644 (file)
--- a/build/buildlib.xs
+++ b/build/buildlib.xs
* This file contains common routines that are used by the various RM \r
* components.\r
*\r
- * Copyright (C) 2012, Texas Instruments, Inc.\r
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
*****************************************************************************/\r
\r
/**************************************************************************\r
diff --git a/config.bld b/config.bld
index 52364eca5f438daab5c059bebea32e7d602214dd..5f9ef0e8f92ab195844d5727b7d2e137deed69b1 100644 (file)
--- a/config.bld
+++ b/config.bld
* and is responsible for configuration of the paths for the various tools\r
* required to build RM.\r
*\r
- * Copyright (C) 2012, Texas Instruments, Inc.\r
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
*****************************************************************************/\r
\r
/* Get the Tools Base directory from the Environment Variable. */\r
diff --git a/docs/Module.xs b/docs/Module.xs
index d72e3b5c7e6208cfffecb48c2d7c11212592a3d0..0c36291b99ac3cb0f4d549a4d19d324ee079df86 100644 (file)
--- a/docs/Module.xs
+++ b/docs/Module.xs
* DESCRIPTION: \r
* This file contains the module specification for the RM Documentation.\r
*\r
- * Copyright (C) 2012, Texas Instruments, Inc.\r
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
*****************************************************************************/\r
\r
/* Load the library utility. */\r
diff --git a/include/Module.xs b/include/Module.xs
index e246743ef9261fe06023f1f98bc7957f42fed397..39336f91adf7b31120b04357d575ff80cb9be86d 100644 (file)
--- a/include/Module.xs
+++ b/include/Module.xs
* DESCRIPTION:
* This file contains the module specification for RM include directory
*
- * Copyright (C) 2012, Texas Instruments, Inc.
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.
*****************************************************************************/
/* Load the library utility. */
index 78fcaa5fbe3ec9015f6740289bbcedc4f0306662..c7273c105b8b4c303a9e60dfcdeeca37f4d75ee1 100644 (file)
--- a/include/rm_dtb_utilloc.h
+++ b/include/rm_dtb_utilloc.h
* Private Resource List and Policy DTB Parsing Utilities
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
extern "C" {
#endif
-/**********************************************************************
- *************Common RM DTB Parsing Defines and Functions**************
- **********************************************************************/
+/* RM external includes */
+#include <ti/drv/rm/rm.h>
/**
* @brief LIBFDT's return codes start at 1. Map a return value of 0 to an okay result
* @brief DTB starting depth for parsing
*/
#define RM_DTB_UTIL_STARTING_DEPTH 0
+/**
+* @brief Linux DTB alias offset not set
+*/
+#define RM_DTB_LINUX_ALIAS_OFFSET_NOT_SET 0xFFFF
+/**
+* @brief Depth of the RM instance nodes in the policy DTB
+*/
+#define RM_POLICY_DTB_INSTANCE_DEPTH 1
+
+/**********************************************************************
+ ******************* Common DTB Parsing Definitions *******************
+ **********************************************************************/
typedef struct Rm_ResourceRange_s {
uint32_t base;
} Rm_ResourceValue;
/**********************************************************************
- ***********Resource List DTB Parsing Defines and Functions************
+ ************* Global Resource List Parsing Definitions ***************
**********************************************************************/
-/**
-* @brief Linux DTB alias offset not set
-*/
-#define RM_DTB_LINUX_ALIAS_OFFSET_NOT_SET 0xFFFF
-
typedef enum {
/** Resource DTB unknown property type */
Rm_resourcePropType_UNKNOWN = 0,
/** Resource DTB resource alias path in Linux DTB */
Rm_resourcePropType_RESOURCE_LINUX_ALIAS,
/** Resource DTB NameServer assignment property type */
- Rm_resourcePropType_NSASSIGNMENT,
+ Rm_resourcePropType_NSASSIGNMENT
} Rm_ResourcePropType;
typedef struct Rm_LinuxAlias_s {
} Rm_LinuxAlias;
typedef struct Rm_NsAssignment_s {
- char nsName[RM_RESOURCE_NAME_MAX_CHARS];
+ char nsName[RM_NAME_MAX_CHARS];
uint32_t resourceBase;
uint32_t resourceLength;
struct Rm_NsAssignment_s *nextNsAssignment;
} Rm_NsAssignment;
-Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char *propertyName);
-Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr, int32_t dtbDataLen);
-void rmDtbUtilResFreeRange(Rm_ResourceRange *rangeList);
-Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtbDataLen,
- int32_t *result);
-void rmDtbUtilResFreeLinuxAlias(Rm_LinuxAlias *aliasList);
-Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t dtbDataLen,
- int32_t *result);
-void rmDtbUtilResFreeNsAssignmentList(Rm_NsAssignment *nsAssignmentList);
-
/**********************************************************************
- ***************Policy DTB Parsing Defines and Functions***************
+ ********************* Policy Parsing Definitions *********************
**********************************************************************/
-/**
-* @brief Depth of the RM instance nodes in the policy DTB
-*/
-#define RM_POLICY_DTB_INSTANCE_DEPTH 1
-
typedef enum {
/** Policy DTB unknown property type */
Rm_policyPropType_UNKNOWN = 0,
/** Policy DTB allocation alignment property type */
Rm_policyPropType_ALLOCATION_ALIGNMENT,
/** Policy DTB valid RM instances property type */
- Rm_policyPropType_VALID_INSTANCES,
+ Rm_policyPropType_VALID_INSTANCES
} Rm_PolicyPropType;
typedef struct Rm_PolicyAssignment_s {
- uint32_t resourceBase;
- uint32_t resourceLength;
- char *permissionsList;
+ uint32_t resourceBase;
+ uint32_t resourceLength;
+ char *permissionsList;
struct Rm_PolicyAssignment_s *nextAssignment;
} Rm_PolicyAssignment;
typedef struct Rm_PolicyValidInst_s {
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
+ char instName[RM_NAME_MAX_CHARS];
struct Rm_PolicyValidInst_s *nextValidInst;
} Rm_PolicyValidInst;
+/**********************************************************************
+ ******************** Linux DTB Parsing Definitions *******************
+ **********************************************************************/
+
+typedef struct Rm_LinuxValueRange_s {
+ uint32_t value;
+ struct Rm_LinuxValueRange_s *nextValue;
+} Rm_LinuxValueRange;
+
+/**********************************************************************
+ *************** Global Resource List Parsing Functions ***************
+ **********************************************************************/
+
+Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char *propertyName);
+Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr, int32_t dtbDataLen);
+void rmDtbUtilResFreeRange(Rm_ResourceRange *rangeList);
+Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtbDataLen,
+ int32_t *result);
+void rmDtbUtilResFreeLinuxAlias(Rm_LinuxAlias *aliasList);
+Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t dtbDataLen,
+ int32_t *result);
+void rmDtbUtilResFreeNsAssignmentList(Rm_NsAssignment *nsAssignmentList);
+
+/**********************************************************************
+ ********************** Policy Parsing Functions***********************
+ **********************************************************************/
+
Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char *propertyName);
Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr, int32_t dtbDataLen);
void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList);
@@ -163,14 +181,9 @@ Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
void rmDtbUtilPolicyFreeValidInstances (Rm_PolicyValidInst *validInstList);
/**********************************************************************
- ****************Linux DTB Parsing Defines and Functions***************
+ ********************* Linux DTB Parsing Functions ********************
**********************************************************************/
-typedef struct Rm_LinuxValueRange_s {
- uint32_t value;
- struct Rm_LinuxValueRange_s *nextValue;
-} Rm_LinuxValueRange;
-
Rm_LinuxValueRange *rmDtbUtilLinuxExtractValues(const void *dtbDataPtr, int32_t dtbDataLen);
void rmDtbUtilLinuxFreeValues(Rm_LinuxValueRange *valueList);
diff --git a/include/rm_loc.h b/include/rm_loc.h
index e62bf7d9b9ee48bed60fa8e394187a0496f806f2..9e7832b537731c8aaab77157be33aec5c4b25c74 100644 (file)
--- a/include/rm_loc.h
+++ b/include/rm_loc.h
* General private data structures of Resource Manager.
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
#include <ti/drv/rm/include/rm_nameserverloc.h>
#include <ti/drv/rm/include/rm_treeloc.h>
-/** Maximum size of a transmittable RM policy in bytes */
-#define RM_MAX_POLICY_SIZE_BYTES (64) // Placeholder: This will change
- // during development
-
-/** Pointer to RM instance's transaction queue */
-typedef void *Rm_TransactionQueue;
-
/**
* @brief RM protocol packet resource information
*/
typedef struct {
/** Resource name of resource affected by command */
- char name[RM_RESOURCE_NAME_MAX_CHARS];
+ char name[RM_NAME_MAX_CHARS];
/** If applicable, start of resource range affected by command. If
* RM_RESOURCE_UNSPECIFIED is assigned the higher level RM agent*/
int32_t base;
int32_t alignment;
/** If applicable, the NameServer name assigned to the specified
* resource. Used for commands centering on RM NameServer actions */
- char nameServerName[RM_RESOURCE_NAME_MAX_CHARS];
+ char nameServerName[RM_NAME_MAX_CHARS];
} Rm_ResourceInfo;
/**
* instance's transaction queue. The transactions track all service
* requests within the RM infrastructure.
*/
-typedef struct {
+typedef struct Rm_Transaction_s {
/** Transaction service type */
Rm_ServiceType type;
/** Local ID of the transaction. */
uint32_t remoteOriginatingId;
/** Name of the RM instance the RM packet, that spawned the transaction,
* originated from */
- char pktSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char pktSrcInstName[RM_NAME_MAX_CHARS];
/** Transaction's associated callback function */
Rm_ServiceCallback callback;
/** Transaction state. The codes are externally visible and tracked
* in rmservices.h */
int32_t state;
/** Name of the RM instance the service originated from */
- char serviceSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char serviceSrcInstName[RM_NAME_MAX_CHARS];
/** Resource information */
Rm_ResourceInfo resourceInfo;
/** Link to the next transaction in the queue */
- void *nextTransaction;
+ struct Rm_Transaction_s *nextTransaction;
} Rm_Transaction;
typedef struct {
typedef struct {
Rm_PolicyValidInstNode *serviceSrcInstNode;
- Rm_AllocatorOp operation;
- uint32_t allocType;
- Rm_ResourceInfo *resourceInfo;
+ Rm_AllocatorOp operation;
+ uint32_t allocType;
+ Rm_ResourceInfo *resourceInfo;
} Rm_AllocatorOpInfo;
typedef struct Rm_Allocator_s {
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS];
+ char resourceName[RM_NAME_MAX_CHARS];
/** Pointer to the first resource entry in the allocator */
- void *allocatorRootEntry;
+ void *allocatorRootEntry;
/** Pointer to next resource allocator */
struct Rm_Allocator_s *nextAllocator;
} Rm_Allocator;
-
typedef struct {
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
+ char instName[RM_NAME_MAX_CHARS];
void *startupDtb;
Rm_PolicyValidInstTree *validInstTree;
uint32_t requestCount;
} Rm_PreMainInst;
typedef struct {
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
+ char instName[RM_NAME_MAX_CHARS];
Rm_InstType instType;
+ Rm_ServiceHandle *serviceHandle;
bool registeredWithDelegateOrServer;
void *policy;
void *staticPolicy;
Rm_PolicyValidInstTree *validInstances;
Rm_Allocator *allocators;
Rm_NameServerTree *nameServer;
- /* RM instance transport parameters */
void *transports;
- /* RM Transaction sequence number counter */
uint32_t transactionSeqNum;
- /* RM transaction queue */
- Rm_TransactionQueue transactionQueue;
- /* Transport API function pointers - not global in case application wants to
- * hook up different transports to RM */
+ Rm_Transaction *transactionQueue;
Rm_TransportCallouts transport;
} Rm_Inst;
index 583ec99c8c7c3ff0731bc49e9ed30e0aa17f70ea..5d94b0b75129939eebedde1e6ca189c907ce6df7 100644 (file)
* Prototypes and data structures for the Resource Manager NameServer.
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
extern "C" {
#endif
-/* RM external includes */
-#include <ti/drv/rm/rm_services.h>
-
/* RM internal includes */
#include <ti/drv/rm/include/rm_treeloc.h>
diff --git a/include/rm_policyloc.h b/include/rm_policyloc.h
index fca977689d0cee3d85cccf79325925b7eafbf1ce..8caf61bc1bfc9fb468da2c715f5f612948c7045c 100644 (file)
--- a/include/rm_policyloc.h
+++ b/include/rm_policyloc.h
* Prototypes and data structures for the Resource Manager Policies.
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
extern "C" {
#endif
+/* RM external includes */
+#include <ti/drv/rm/rm.h>
+
/* RM internal includes */
#include <ti/drv/rm/include/rm_treeloc.h>
((permBits >> permTypeShift) & 0x1)
typedef struct Rm_Permission_s {
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
+ char instName[RM_NAME_MAX_CHARS];
Rm_PolicyPermBits permissionBits;
struct Rm_Permission_s *nextPermission;
} Rm_PolicyPermission;
@@ -119,11 +122,11 @@ Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_PolicyValidInstTree *validIn
Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_PolicyValidInstTree *validInstTree);
bool rmPolicyCheckPrivilege(Rm_PolicyCheckCfg *privilegeCfg, int32_t *result);
uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validInstNode,
- int32_t resourceOffset, uint32_t allocType,
- int32_t *result);
+ int32_t resourceOffset, uint32_t allocType,
+ int32_t *result);
uint32_t rmPolicyGetResourceAlignment(void *policyDtb, int32_t resourceOffset);
int32_t rmPolicyGetResourceOffset(void *policyDtb, char *resourceName);
-int32_t rmPolicyValidatePolicyResourceNames(void *allocatorList, void *policyDtb);
+int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList);
int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validInstTree);
Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, int32_t *result);
void rmPolicyFreeValidInstTree(Rm_PolicyValidInstTree *validInstTree);
index 8195ebd6be16194c2caad99203c10aafe253b706..e8003a5521daa18450c4fa60c2d121af6d6419b6 100644 (file)
--- a/include/rm_servicesloc.h
+++ b/include/rm_servicesloc.h
* Private data structures of Resource Manager services layer.
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
index bf5c3e16a51305ae309a778283eba338cba93371..a9456a6b4db742526f218520e61b40ae24b8a748 100644 (file)
/*
- * file rmtransportloc.h
+ * file rm_transportloc.h
*
* Private data structures of Resource Manager transport layer.
*
* ============================================================================
- * (C) Copyright 2012, Texas Instruments, Inc.
+ * (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-#ifndef RMTRANSPORTLOC_H_
-#define RMTRANSPORTLOC_H_
+#ifndef RM_TRANSPORTLOC_H_
+#define RM_TRANSPORTLOC_H_
#ifdef __cplusplus
extern "C" {
/** The remote RM instance type */
Rm_InstType remoteInstType;
/** The remote RM instance name */
- char remoteInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char remoteInstName[RM_NAME_MAX_CHARS];
/** Link to the next route node in the route map list */
struct Rm_Transport_s *nextTransport;
} Rm_Transport;
*/
typedef struct {
/** The transaction ID associated with the request packet */
- uint32_t requestId;
+ uint32_t requestId;
/** The resource request type */
Rm_ResourceReqPktType resourceReqType;
/** RM instance name from which the request packet originated. Used by
* receiving instance to route the response */
- char pktSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char pktSrcInstName[RM_NAME_MAX_CHARS];
/** Name of RM instance that is issuing the service request. The instance
* name will be used to validate the request against the RM policy defined
* for the instance. */
- char serviceSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char serviceSrcInstName[RM_NAME_MAX_CHARS];
/** Resource request information */
- Rm_ResourceInfo resourceInfo;
+ Rm_ResourceInfo resourceInfo;
} Rm_ResourceRequestPkt;
/**
/** responseID will equal the requestId received in the resource request
* packet. This ID should be associated with a transaction stored in
* the RM instance that sent the resource request packet */
- uint32_t responseId;
+ uint32_t responseId;
/** State of the request. Resource request, denied, or error. The
* return values are externally visible so they're tracked in rmservice.h */
- int32_t requestState;
+ int32_t requestState;
/* Resource response information */
Rm_ResourceInfo resourceInfo;
} Rm_ResourceResponsePkt;
*/
typedef struct {
/** The transaction ID associated with the request packet */
- uint32_t requestId;
+ uint32_t requestId;
/** The resource request type */
Rm_NsReqPktType nsRequestType;
/** RM instance name from which the request packet originated. Used by
* receiving instance to route the response */
- char pktSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char pktSrcInstName[RM_NAME_MAX_CHARS];
/** RM instance name making the service request. Policies may restrict who
* can and cannot map and unmap resources via the RM NameServer */
- char serviceSrcInstName[RM_INSTANCE_NAME_MAX_CHARS];
+ char serviceSrcInstName[RM_NAME_MAX_CHARS];
/** Resource request information */
Rm_ResourceInfo resourceInfo;
} Rm_NsRequestPkt;
uint32_t responseId;
/** State of the request. Resource request, denied, or error. The
* return values are externally visible so they're tracked in rmservice.h */
- int32_t requestState;
+ int32_t requestState;
} Rm_NsResponsePkt;
-/**
- * @brief Policy Request Packet - Packet used by a RM instance to request an
- * update to its policy data (supported on Client Delegates and Servers only)
- */
-typedef struct {
- /** The transaction ID associated with the request packet */
- uint32_t requestId;
- /** Name of RM instance that is issuing the policy request. The instance
- * name will be used to validate the request against the RM policy defined
- * for the instance in the global policy.
- * WARNING: Only Client Delegates and Servers can request policy updates */
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
-} Rm_PolicyRequestPkt;
-
-/**
- * @brief Policy Change Packet - Provides policy changes to RM instances that
- * support policy storage (Client Delegates and Servers)
- */
-typedef struct {
- /** responseID will equal the requestId received in the resource request
- * packet. This ID should be associated with a transaction stored in
- * the RM instance that sent the resource request packet */
- uint32_t responseId;
- /** Byte array containing new policy data for receiving RM instance */
- char policyData[RM_MAX_POLICY_SIZE_BYTES];
-} Rm_PolicyChangePkt;
-
-/**
- * @brief Resource Pool Modification Request Packet Types
- */
-typedef enum {
- /** Resource pool allocation request */
- Rm_resPoolModType_ALLOCATE = 0,
- /** Resource pool free request */
- Rm_resPoolModType_FREE = 1
-} Rm_ResourcePoolModReqType;
-
-/**
- * @brief Resource Pool Modification Request Packet - Packet sent to RM Server from
- * RM Client Delegates in order to request resource pool modifications on
- * the Client Delegate. The Client Delegate can request more resource's for
- * its local resource pool or it can free resources from its resource pool back
- * to the Server. */
-typedef struct {
- /** The transaction ID associated with the request packet */
- uint32_t requestId;
- /** The resource pool modification request type */
- Rm_ResourcePoolModReqType resourcePoolModReqType;
- /** Name of RM Client Delegate instance that is issuing the resource pool
- * modification request. The instance name will be used to validate the
- * request against the RM policy defined for the instance. */
- char instName[RM_INSTANCE_NAME_MAX_CHARS];
- /** Resource pool resource request information */
- Rm_ResourceInfo resourceInfo;
-} Rm_ResourcePoolModRequestPkt;
-
-/**
- * @brief Resource Pool Modification Response Packet - Packet sent to RM Client
- * Delegates from RM Servers in response to resource pool modification requests.
- * The packet will contain resource response information based on the request
- */
-typedef struct {
- /** responseID will equal the requestId received in the resource pool mod request
- * packet. This ID should be associated with a transaction stored in
- * the RM instance that sent the resource request packet */
- uint32_t responseId;
- /** Result of the resource pool mod request. Resource request, denied, or error. The
- * return values are externally visible so they're tracked in rmservice.h */
- int32_t requestResult;
- /* Resource pool resource response information */
- Rm_ResourceInfo resourceInfo;
-} Rm_ResourcePoolModResponsePkt;
-
Rm_Transport *rmTransportFindRemoteName(Rm_Transport *transports, char *remoteName);
Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports, Rm_InstType remoteInstType);
Rm_Packet *rmTransportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_Transport *dstTransportNode,
@@ -253,5 +180,5 @@ Rm_Packet *rmTransportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_Transport *dstTran
}
#endif
-#endif /* RMTRANSPORTLOC_H_ */
+#endif /* RM_TRANSPORTLOC_H_ */
diff --git a/include/rm_treeloc.h b/include/rm_treeloc.h
index a32ed169b9b890298d939c0334c3f4f6a00cf699..24e882373b8b2fb9da330b3e978f1f06ab8684fb 100644 (file)
--- a/include/rm_treeloc.h
+++ b/include/rm_treeloc.h
extern "C" {
#endif
+/* Standard includes */
+#include <stdint.h>
+#include <stdbool.h>
+
/* RM external includes */
#include <ti/drv/rm/rm.h>
-#include <ti/drv/rm/rm_services.h>
/* AVL BBST includes */
#include <ti/drv/rm/include/tree.h>
typedef struct _Rm_NameServerNode {
RB_ENTRY(_Rm_NameServerNode) linkage;
- char objName[RM_RESOURCE_NAME_MAX_CHARS];
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS];
+ char objName[RM_NAME_MAX_CHARS];
+ char resourceName[RM_NAME_MAX_CHARS];
uint32_t resourceBase;
uint32_t resourceLength;
} Rm_NameServerNode;
typedef struct _Rm_PolicyValidInstNode {
RB_ENTRY(_Rm_PolicyValidInstNode) linkage;
- char name[RM_INSTANCE_NAME_MAX_CHARS];
+ char name[RM_NAME_MAX_CHARS];
uint32_t allocRefCount;
bool deletePending;
} Rm_PolicyValidInstNode;
******************** Tree Prototype Generation ***********************
**********************************************************************/
-RB_PROTOTYPE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, nameServerNodeCompare);
-RB_PROTOTYPE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, policyValidInstNodeCompare);
-RB_PROTOTYPE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, resourceNodeCompare);
+RB_PROTOTYPE(_Rm_NameServerTree, _Rm_NameServerNode, linkage, nameServerNodeCompare)
+RB_PROTOTYPE(_Rm_PolicyValidInstTree, _Rm_PolicyValidInstNode, linkage, policyValidInstNodeCompare)
+RB_PROTOTYPE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, resourceNodeCompare)
#ifdef __cplusplus
}
diff --git a/package.bld b/package.bld
index 9fd9ff73e32c51fc07bd2df550066f6a229cf19e..a05e6807f08c0779ff3227a1109cb76f19efefb1 100644 (file)
--- a/package.bld
+++ b/package.bld
* Example for a valid command:\r
* xdc XDCARGS="SETUP" release \r
*\r
- * Copyright (C) 2012, Texas Instruments, Inc.\r
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
*****************************************************************************/\r
\r
/* List of all subdirectories that combine to make the RM Package. */\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rm.h";\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rm_services.h";\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rm_transport.h";\r
-Pkg.otherFiles[Pkg.otherFiles.length++] = "rm_types.h";\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rm_osal.h";\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rmver.h";\r
Pkg.otherFiles[Pkg.otherFiles.length++] = "rmver.h.xdt";\r
diff --git a/package.xdc b/package.xdc
index 5bee1a47d96b99b265f688272f8e1a1776d6f298..da62e2bf8056626aa82d55852186d07dadc0c170 100644 (file)
--- a/package.xdc
+++ b/package.xdc
* DESCRIPTION: \r
* This file contains the package specification for the RM library\r
*\r
- * Copyright (C) 2012, Texas Instruments, Inc.\r
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
*****************************************************************************/\r
\r
package ti.drv.rm[2, 0, 0, 0] {\r
index d10d6ead552adcbfa2f938eff8903421945d5cab..a414acb3dcac7d10bb964082e3b4f277c2522597 100644 (file)
--- a/rm.h
+++ b/rm.h
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
extern "C" {
#endif
+/* Standard includes */
+#include <stdint.h>
+
/* RM version */
#include <ti/drv/rm/rmver.h>
* @section intro Introduction
*
* The Resource Manager low level driver (RM LLD) is designed to provide initialization and permissions checking
- * for LLD resources. A system integrator can specify DSP permissions for LLD resources within the system.
- * The resource permissions are stored in the RM LLD and used to validate resource requests from supported LLDs.
- * Currently, the RM LLD supports permissions for the following LLDs
- * - QMSS
- * - CPPI
- * - PA
- * For information on the specific resources supported with each LLD please see @ref RM_LLD_RESOURCE_TABLE.
- *
- * The system integrator must specify the supported LLD resource permissions for all DSPs prior to compile time.
- * An array of @ref Rm_Resource objects must be created. Each @ref Rm_Resource entry in the array specifies
- * a resource type, start and end range for the resource, and the initialization and usage permissions for the
- * resource for each DSP. For an example resource table definitions please see the @ref rmResourceTable array
- * defined in the resource_table\ directory. This resource table assigns full initialization and usage permissions
- * to all DSPs for all supported resources. Please note that the resouce table must start with the
- * @ref RM_RESOURCE_MAGIC_NUMBER entry and end with the @ref RM_RESOURCE_FINAL_ENTRY. These
- * first and last entries are used the RM LLD to validate and parse the resource table.
- *
- * The RM LLD must be initialized and started prior to all supported LLD initialization and start routines. The
- * @ref Rm_init function should be invoked, and passed a pointer to the integrator defined resource table, on the
- * master DSP core in the system. All other DSP cores should invoke the @ref Rm_start API. The @ref Rm_init
- * function first initializes the internal permission tables to deny all DSPs access to all resources. Next the
- * @ref Rm_init function parses the resource table provided and copies all specified permissions into the internal
- * tables. When the permission transfer completes the @ref Rm_init function writes a global synchronization
- * object which the @ref Rm_start functions are spinning on. The slave cores that have invoked @ref Rm_start
- * will stop spinning once the global synchronization has been written. At this time @ref Rm_start will invalidate
- * all internal permission tables so that no further cache invalidate operations need to be performed when
- * checking resource permissions in the data path. The upfront cache invalidate operation is possible because
- * the RM LLD does not allow dynamic resource permission modifications. The permissions defined by the system
- * integrator and loaded during RM initialization are static throughout the system up-time.
- *
- * The RM LLD must be registered with a supported LLD in order for the supported LLD to perform resource
- * permission checks. If the RM LLD is not registered with a supported LLD the LLD will operate as if the RM LLD
- * is not there. This maintains full backwards compatability with existing applications not using the RM LLD. In order
- * to register the RM LLD with supported LLDs the following steps should be taken
- * - Get a @ref Rm_Handle via the @ref Rm_getHandle API on each DSP that uses the RM LLD.
- * - Register the RM LLD with the supported LLDs by passing the @ref Rm_Handle to the
- * LLD's <<LLD name>>_startCfg API. Again, this should be performed on all DSP cores using the RM LLD.
- * Note: The master core for the QMSS LLD should have the @ref Rm_Handle registered via the Qmss_init API.
- * After registering the RM LLD with supported LLDs all supported LLD resources covered by the RM LLD will invoke
- * permission check callouts to the RM. A permission denied or approved response will be given back to the
- * invoking LLD based on the permissions stored in the RM LLD for the resource.
- *
- * All internal RM LLD permission tables are placed into a single memory section called ".rm". This memory section
- * MUST be placed in shared memory (MSMC or DDR). The permission tables are shared between all DSPs utilizing
- * the RM LLD.
- *
- * In summary, the initialization flow if the RM LLD is to be utilized should look like the following:
- *
- * Master DSP Core:
- * - Call @ref Rm_init passing in the system integrator defined resource table
- * - Call @ref Rm_getHandle
- * - Call supported LLD _init or _create functions (for QMSS pass the @ref Rm_Handle inside the
- * Qmss_GlobalConfigParams structure)
- * - Call supported LLD _startCfg functions passing the @ref Rm_Handle as an argument
- *
- * Slave DSP Cores:
- * - Call @ref Rm_start
- * - Call @ref Rm_getHandle
- * - Call supported LLD _start functions (if supported)
- * - Call supported LLD _startCfg functions passing the @ref Rm_Handle as an argument
*
*/
-/* Define RM_LLD_API as a master group in Doxygen format and add all RM LLD API
+/* Define RM_API as a master group in Doxygen format and add all RM API
definitions to this group. */
-/** @defgroup RM_LLD_API RM LLD Module API
+/** @defgroup RM_API Resource Manager API
* @{
*/
/** @} */
/**
@defgroup RM_TRANSPORT_API RM Transport-Layer API
-@ingroup RM_LLD_API
+@ingroup RM_API
*/
/**
@defgroup RM_SERVICES_API RM Registered Component Services API
-@ingroup RM_LLD_API
-*/
-/**
-@defgroup RM_POLICY_API RM Policy modification API
-@ingroup RM_LLD_API
+@ingroup RM_API
*/
/* TODO: CANT CONFLICT WITH OTHER ERROR CODES INCLUDING LIBFDT */
#define RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INSTANCE_NAME_IN_ASSIGNMENT_TOO_LONG -269
#define RM_INIT_ERROR_NS_ASSIGNMENT_NAME_TOO_LONG -270
#define RM_INIT_ERROR_GRL_INVALID_LINUX_ALIAS_FORMAT -271
+#define RM_INIT_ERROR_SERVICE_HANDLE_MEMORY_ALLOC_FAILED -272
+#define RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_ALLOCATED -273
+#define RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_CLOSED_FOR_INSTANCE -274
+
+/** RM Service Request State Codes and Errors */
+/** RM Service Request State Code Base */
+#define RM_SERVICE_STATE_BASE (0)
+/** RM internal state okay - This value is for internal use by RM. It should never be
+ * seen as a return value during normal operation */
+#define RM_SERVICE_STATE_OKAY (RM_SERVICE_STATE_BASE)
+/** RM service is being processed. Typically this means the service is
+ * being sent to a higher level RM agent for processing */
+#define RM_SERVICE_PROCESSING (RM_SERVICE_STATE_BASE+1)
+/** RM service was approved. The resource data in the response is valid if
+ * the service has been approved. */
+#define RM_SERVICE_APPROVED_AND_COMPLETED (RM_SERVICE_STATE_BASE+2)
+/** Beginning of resource denied reasons */
+#define RM_SERVICE_DENIED_BEGIN (RM_SERVICE_STATE_BASE+3)
+/** RM could not find an allocator for the resource specified with the provided name */
+#define RM_SERVICE_DENIED_RESOURCE_DOES_NOT_EXIST (RM_SERVICE_DENIED_BEGIN)
+/** A resource value within the specifed base+range could not be found within the resource's
+ * allocator. No action was taken on the resources. */
+#define RM_SERVICE_DENIED_RESOURCE_VALUE_RANGE_DOES_NOT_EXIST (RM_SERVICE_DENIED_BEGIN+1)
+/** A resource value within the specifed base+range was not allocated to the RM instance
+ * that is the source of the request. No action was taken on the resources. */
+#define RM_SERVICE_DENIED_RESOURCE_NOT_ALLOCATED_TO_INSTANCE_REQUESTING_THE_SERVICE (RM_SERVICE_DENIED_BEGIN+2)
+/** A resource value within the specifed base+range is already free */
+#define RM_SERVICE_DENIED_RESOURCE_ALREADY_FREE (RM_SERVICE_DENIED_BEGIN+3)
+/** A resource value within the specifed base+range is already allocated to another
+ * RM instance. */
+#define RM_SERVICE_DENIED_RESOURCE_ALREADY_ALLOCATED (RM_SERVICE_DENIED_BEGIN+4)
+/** The resource range specified for freeing included free and allocated resoruces. */
+#define RM_SERVICE_DENIED_INVALID_RESOURCE_RANGE (RM_SERVICE_DENIED_BEGIN+5)
+/** No free resource ranges could be found that satisfy the resource base, length, and
+ * alignment requirements */
+#define RM_SERVICE_DENIED_RESOURCE_ALLOCATION_REQUIREMENTS_COULD_NOT_BE_SATISFIED (RM_SERVICE_DENIED_BEGIN+6)
+/** The RM instance requesting the service is not defined in the policy */
+#define RM_SERVICE_DENIED_RM_INST_NOT_DEFINED_IN_POLICY (RM_SERVICE_DENIED_BEGIN+7)
+/** The resource in the service request is not defined in the policy */
+#define RM_SERVICE_DENIED_RESOURCE_NOT_DEFINED_IN_POLICY (RM_SERVICE_DENIED_BEGIN+8)
+/** The resource has multiple assigned range definitions */
+#define RM_SERVICE_DENIED_ASSIGNED_RANGE_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+9)
+/** The resource has multiple allocation size definitions */
+#define RM_SERVICE_DENIED_ALLOCATION_SIZE_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+10)
+/** The resource has multiple assigned name definitions */
+#define RM_SERVICE_DENIED_ASSIGNED_NAME_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+11)
+/** The resource has multiple allocation alignment definitions */
+#define RM_SERVICE_DENIED_ALLOCATION_ALIGNMENT_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+12)
+/** The resource node in the policy has an unknown property type */
+#define RM_SERVICE_DENIED_UNKNOWN_POLICY_PROPERTY (RM_SERVICE_DENIED_BEGIN+13)
+/** The policy does not approve of the resources requested by the RM instance in the service
+ * request */
+#define RM_SERVICE_DENIED_POLICY_DENIAL (RM_SERVICE_DENIED_BEGIN+14)
+/** Attempt to add object to NameServer denied: The object name already exists in the NameServer */
+#define RM_SERVICE_DENIED_NAMESERVER_ERROR_NAME_ALREADY_EXISTS (RM_SERVICE_DENIED_BEGIN+15)
+/** No valid ranges were specified for the resource within the RM instance's node within the policy.
+ * By default all resource requests for this resource are denied */
+#define RM_SERVICE_DENIED_POLICY_DENIAL_NO_RANGES_SPECIFIED (RM_SERVICE_DENIED_BEGIN+16)
+/** The instance name of the service requesting instance is not in the policy valid instance list */
+#define RM_SERVICE_DENIED_ORIGINATING_INSTANCE_NAME_NOT_VALID (RM_SERVICE_DENIED_BEGIN+17)
+/** The policy does not specify any assignment ranges for the resource in the service request */
+#define RM_SERVICE_DENIED_NO_RANGE_ASSIGNMENTS_FOR_POLICY (RM_SERVICE_DENIED_BEGIN+18)
+/** The resource couldn't be allocated because the requesting instance was not given the init/use
+ * permissions in the policy */
+#define RM_SERVICE_DENIED_INIT_USE_PERMISSION_DENIED (RM_SERVICE_DENIED_BEGIN+19)
+/** The resource couldn't be allocated because the requesting instance has exclusive privileges in the
+ * policy but the resource was already allocated */
+#define RM_SERVICE_DENIED_REQUESTER_HAS_EXCLUSIVE_PRIV_BUT_RESOURCE_ALLOCATED (RM_SERVICE_DENIED_BEGIN+20)
+/** The resource couldn't be allocated because it was already allocated to an instance with exclusive
+ * privileges for the resource */
+#define RM_SERVICE_DENIED_RESOURCE_ALLOCATED_TO_INSTANCE_WITH_EXCLUSIVE_PRIV (RM_SERVICE_DENIED_BEGIN+21)
+/** Pre main request was not an allocate use or allocate init request */
+#define RM_SERVICE_DENIED_INVALID_PREMAIN_REQUEST (RM_SERVICE_DENIED_BEGIN+22)
+/** Startup policy denied pre-main allocation request */
+#define RM_SERVICE_DENIED_POLICY_DENIED_PREMAIN_ALLOCATION (RM_SERVICE_DENIED_BEGIN+23)
+/** End of resource denied reasons */
+#define RM_SERVICE_DENIED_END (RM_SERVICE_DENIED_BEGIN+23)
+
+/** RM Service Request Error Code Base */
+#define RM_SERVICE_ERROR_BASE (-64)
+/** RM service request type not recognized */
+#define RM_SERVICE_ERROR_INVALID_SERVICE_TYPE (RM_SERVICE_ERROR_BASE)
+/** RM Service request was not provided a component callback
+ * function. Service requests may result in blocking operations. A callback
+ * function must always be provided with a service request since
+ * blocked or non-blocked operations cannot be promised. */
+#define RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED (RM_SERVICE_ERROR_BASE-1)
+/** RM service request needs to be forwarded to another RM agent but no transports
+ * have been registered */
+#define RM_SERVICE_ERROR_NO_TRANSPORT_REGISTERED (RM_SERVICE_ERROR_BASE-2)
+/** RM service request needs to be forwarded but no client delegate or server has
+ * been registered with the RM instance */
+#define RM_SERVICE_ERROR_NOT_REGISTERED_WITH_DEL_OR_SERVER (RM_SERVICE_ERROR_BASE-3)
+/** RM service request needs to be forwarded but the transport packet alloc API
+ * has not been provided */
+#define RM_SERVICE_ERROR_TRANSPORT_PKT_ALLOC_API_NULL (RM_SERVICE_ERROR_BASE-4)
+/** A failure occurred within a registered transport's packet alloc API */
+#define RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR (RM_SERVICE_ERROR_BASE-5)
+/** RM service request needs to be forwarded but the buffer allocated by transport
+ * is not large enough to fit the RM transport packet */
+#define RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL (RM_SERVICE_ERROR_BASE-6)
+/** RM service request needs to be forwarded but the transport returned an error
+ * when trying to send the RM packet to the higher level agent */
+#define RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR (RM_SERVICE_ERROR_BASE-7)
+/** RM service response from higher level agent did not match any requests made
+ * by the provided RM instance */
+#define RM_SERVICE_ERROR_TRANSACTION_DOES_NOT_EXIST_FOR_THIS_RM_INSTANCE (RM_SERVICE_ERROR_BASE-8)
+/** RM failed to allocate memory for new service transaction */
+#define RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE (RM_SERVICE_ERROR_BASE-9)
+/** RM could not find the service transaction in the RM instance's transaction queue */
+#define RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-10)
+/** A failure occurred within a registered transport's packet free API */
+#define RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR (RM_SERVICE_ERROR_BASE-11)
+/** Invalid NameServer object modification on non-Server instance */
+#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_MOD_ON_INVALID_INSTANCE (RM_SERVICE_ERROR_BASE-12)
+/** Request failed because both a NameServer name and a resource range were specified */
+#define RM_SERVICE_ERROR_NAMESERVER_NAME_AND_RESOURCE_RANGE_BOTH_DEFINED (RM_SERVICE_ERROR_BASE-13)
+/** Error occurred when trying to add an object to the NameServer */
+#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_ADD_FAILED (RM_SERVICE_ERROR_BASE-14)
+/** Could not find the object specified in the service request in the NameServer */
+#define RM_SERVICE_ERROR_NAMESERVER_ERROR_NAME_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-15)
+
+/** RM Transport Result Return Codes */
+/** RM Transport Success Code Base */
+#define RM_TRANSPORT_OK_BASE (0)
+/** RM transport action was successful. */
+#define RM_TRANSPORT_SUCCESSFUL (RM_TRANSPORT_OK_BASE)
+
+/** RM Transport Error Code Base */
+#define RM_TRANSPORT_ERROR_BASE (-64)
+/** RM transport handle has not been registered with the RM instance */
+#define RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED (RM_TRANSPORT_ERROR_BASE-1)
+/** RM packets are available but an error was encountered during reception */
+#define RM_TRANSPORT_ERROR_PACKET_RECEPTION_ERROR (RM_TRANSPORT_ERROR_BASE-3)
+/** RM received a packet with an unknown RM packet type */
+#define RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE (RM_TRANSPORT_ERROR_BASE-4)
+/** RM resource request transaction could not be found matching the response received */
+#define RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-5)
+/** RM NameServer request transaction could not be found matching the response received */
+#define RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-6)
/**
- * @brief Maximum number of characters in a RM instance name
+ * @brief Maximum number of characters allowed for RM instance, resource, and
+ * NameServer names.
*/
-#define RM_INSTANCE_NAME_MAX_CHARS (32)
+#define RM_NAME_MAX_CHARS (32)
/**
* @brief RM Handle provided to application. The RM Handle is used by the
diff --git a/rm_osal.h b/rm_osal.h
index 9e92e7e79734354290815f8a5cf32453ae233ed0..12ed993d769e693d2acfb5ee5454425c7957cdbf 100644 (file)
--- a/rm_osal.h
+++ b/rm_osal.h
* memcpy/memset prototypes here. This #include prevents warnings in
* other code that unintentionally worked because of these prototypes
*/
-#include <string.h>
#include <xdc/runtime/System.h>
diff --git a/rm_services.h b/rm_services.h
index bc23dcb5d4b74327ba5c88ed1bb5c8b4d236b890..188ca45cdd783c27f46cc25a691d991c7c5e0a6a 100644 (file)
--- a/rm_services.h
+++ b/rm_services.h
/**
- * @file rmservices.h
+ * @file rm_services.h
*
* @brief
* This is the RM include file for services provided to components that
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-#ifndef RMSERVICES_H_
-#define RMSERVICES_H_
+#ifndef RM_SERVICES_H_
+#define RM_SERVICES_H_
#ifdef __cplusplus
extern "C" {
#include <ti/drv/rm/rm.h>
/**
-@addtogroup RMSERVICES_API
+@addtogroup RM_SERVICES_API
@{
*/
-/** RM Service Request State Codes and Errors */
-/** RM Service Request State Code Base */
-#define RM_SERVICE_STATE_BASE (0)
-/** RM internal state okay - This value is for internal use by RM. It should never be
- * seen as a return value during normal operation */
-#define RM_SERVICE_STATE_OKAY (RM_SERVICE_STATE_BASE)
-/** RM service is being processed. Typically this means the service is
- * being sent to a higher level RM agent for processing */
-#define RM_SERVICE_PROCESSING (RM_SERVICE_STATE_BASE+1)
-/** RM service was approved. The resource data in the response is valid if
- * the service has been approved. */
-#define RM_SERVICE_APPROVED_AND_COMPLETED (RM_SERVICE_STATE_BASE+2)
-/** Beginning of resource denied reasons */
-#define RM_SERVICE_DENIED_BEGIN (RM_SERVICE_STATE_BASE+3)
-/** RM could not find an allocator for the resource specified with the provided name */
-#define RM_SERVICE_DENIED_RESOURCE_DOES_NOT_EXIST (RM_SERVICE_DENIED_BEGIN)
-/** A resource value within the specifed base+range could not be found within the resource's
- * allocator. No action was taken on the resources. */
-#define RM_SERVICE_DENIED_RESOURCE_VALUE_RANGE_DOES_NOT_EXIST (RM_SERVICE_DENIED_BEGIN+1)
-/** A resource value within the specifed base+range was not allocated to the RM instance
- * that is the source of the request. No action was taken on the resources. */
-#define RM_SERVICE_DENIED_RESOURCE_NOT_ALLOCATED_TO_INSTANCE_REQUESTING_THE_SERVICE (RM_SERVICE_DENIED_BEGIN+2)
-/** A resource value within the specifed base+range is already free */
-#define RM_SERVICE_DENIED_RESOURCE_ALREADY_FREE (RM_SERVICE_DENIED_BEGIN+3)
-/** A resource value within the specifed base+range is already allocated to another
- * RM instance. */
-#define RM_SERVICE_DENIED_RESOURCE_ALREADY_ALLOCATED (RM_SERVICE_DENIED_BEGIN+4)
-/** The resource range specified for freeing included free and allocated resoruces. */
-#define RM_SERVICE_DENIED_INVALID_RESOURCE_RANGE (RM_SERVICE_DENIED_BEGIN+5)
-/** No free resource ranges could be found that satisfy the resource base, length, and
- * alignment requirements */
-#define RM_SERVICE_DENIED_RESOURCE_ALLOCATION_REQUIREMENTS_COULD_NOT_BE_SATISFIED (RM_SERVICE_DENIED_BEGIN+6)
-/** The RM instance requesting the service is not defined in the policy */
-#define RM_SERVICE_DENIED_RM_INST_NOT_DEFINED_IN_POLICY (RM_SERVICE_DENIED_BEGIN+7)
-/** The resource in the service request is not defined in the policy */
-#define RM_SERVICE_DENIED_RESOURCE_NOT_DEFINED_IN_POLICY (RM_SERVICE_DENIED_BEGIN+8)
-/** The resource has multiple assigned range definitions */
-#define RM_SERVICE_DENIED_ASSIGNED_RANGE_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+9)
-/** The resource has multiple allocation size definitions */
-#define RM_SERVICE_DENIED_ALLOCATION_SIZE_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+10)
-/** The resource has multiple assigned name definitions */
-#define RM_SERVICE_DENIED_ASSIGNED_NAME_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+11)
-/** The resource has multiple allocation alignment definitions */
-#define RM_SERVICE_DENIED_ALLOCATION_ALIGNMENT_SPECIFICATION_ERROR (RM_SERVICE_DENIED_BEGIN+12)
-/** The resource node in the policy has an unknown property type */
-#define RM_SERVICE_DENIED_UNKNOWN_POLICY_PROPERTY (RM_SERVICE_DENIED_BEGIN+13)
-/** The policy does not approve of the resources requested by the RM instance in the service
- * request */
-#define RM_SERVICE_DENIED_POLICY_DENIAL (RM_SERVICE_DENIED_BEGIN+14)
-/** Attempt to add object to NameServer denied: The object name already exists in the NameServer */
-#define RM_SERVICE_DENIED_NAMESERVER_ERROR_NAME_ALREADY_EXISTS (RM_SERVICE_DENIED_BEGIN+15)
-/** No valid ranges were specified for the resource within the RM instance's node within the policy.
- * By default all resource requests for this resource are denied */
-#define RM_SERVICE_DENIED_POLICY_DENIAL_NO_RANGES_SPECIFIED (RM_SERVICE_DENIED_BEGIN+16)
-/** The instance name of the service requesting instance is not in the policy valid instance list */
-#define RM_SERVICE_DENIED_ORIGINATING_INSTANCE_NAME_NOT_VALID (RM_SERVICE_DENIED_BEGIN+17)
-/** The policy does not specify any assignment ranges for the resource in the service request */
-#define RM_SERVICE_DENIED_NO_RANGE_ASSIGNMENTS_FOR_POLICY (RM_SERVICE_DENIED_BEGIN+18)
-/** The resource couldn't be allocated because the requesting instance was not given the init/use
- * permissions in the policy */
-#define RM_SERVICE_DENIED_INIT_USE_PERMISSION_DENIED (RM_SERVICE_DENIED_BEGIN+19)
-/** The resource couldn't be allocated because the requesting instance has exclusive privileges in the
- * policy but the resource was already allocated */
-#define RM_SERVICE_DENIED_REQUESTER_HAS_EXCLUSIVE_PRIV_BUT_RESOURCE_ALLOCATED (RM_SERVICE_DENIED_BEGIN+20)
-/** The resource couldn't be allocated because it was already allocated to an instance with exclusive
- * privileges for the resource */
-#define RM_SERVICE_DENIED_RESOURCE_ALLOCATED_TO_INSTANCE_WITH_EXCLUSIVE_PRIV (RM_SERVICE_DENIED_BEGIN+21)
-/** Pre main request was not an allocate use or allocate init request */
-#define RM_SERVICE_DENIED_INVALID_PREMAIN_REQUEST (RM_SERVICE_DENIED_BEGIN+22)
-/** Startup policy denied pre-main allocation request */
-#define RM_SERVICE_DENIED_POLICY_DENIED_PREMAIN_ALLOCATION (RM_SERVICE_DENIED_BEGIN+23)
-/** End of resource denied reasons */
-#define RM_SERVICE_DENIED_END (RM_SERVICE_DENIED_BEGIN+23)
-
-/** RM Service Request Error Code Base */
-#define RM_SERVICE_ERROR_BASE (-64)
-/** RM service request type not recognized */
-#define RM_SERVICE_ERROR_INVALID_SERVICE_TYPE (RM_SERVICE_ERROR_BASE)
-/** RM Service request was not provided a component callback
- * function. Service requests may result in blocking operations. A callback
- * function must always be provided with a service request since
- * blocked or non-blocked operations cannot be promised. */
-#define RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED (RM_SERVICE_ERROR_BASE-1)
-/** RM service request needs to be forwarded to another RM agent but no transports
- * have been registered */
-#define RM_SERVICE_ERROR_NO_TRANSPORT_REGISTERED (RM_SERVICE_ERROR_BASE-2)
-/** RM service request needs to be forwarded but no client delegate or server has
- * been registered with the RM instance */
-#define RM_SERVICE_ERROR_NOT_REGISTERED_WITH_DEL_OR_SERVER (RM_SERVICE_ERROR_BASE-3)
-/** RM service request needs to be forwarded but the transport packet alloc API
- * has not been provided */
-#define RM_SERVICE_ERROR_TRANSPORT_PKT_ALLOC_API_NULL (RM_SERVICE_ERROR_BASE-4)
-/** A failure occurred within a registered transport's packet alloc API */
-#define RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR (RM_SERVICE_ERROR_BASE-5)
-/** RM service request needs to be forwarded but the buffer allocated by transport
- * is not large enough to fit the RM transport packet */
-#define RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL (RM_SERVICE_ERROR_BASE-6)
-/** RM service request needs to be forwarded but the transport returned an error
- * when trying to send the RM packet to the higher level agent */
-#define RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR (RM_SERVICE_ERROR_BASE-7)
-/** RM service response from higher level agent did not match any requests made
- * by the provided RM instance */
-#define RM_SERVICE_ERROR_TRANSACTION_DOES_NOT_EXIST_FOR_THIS_RM_INSTANCE (RM_SERVICE_ERROR_BASE-8)
-/** RM failed to allocate memory for new service transaction */
-#define RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE (RM_SERVICE_ERROR_BASE-9)
-/** RM could not find the service transaction in the RM instance's transaction queue */
-#define RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-10)
-/** A failure occurred within a registered transport's packet free API */
-#define RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR (RM_SERVICE_ERROR_BASE-11)
-/** Invalid NameServer object modification on non-Server instance */
-#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_MOD_ON_INVALID_INSTANCE (RM_SERVICE_ERROR_BASE-12)
-/** Request failed because both a NameServer name and a resource range were specified */
-#define RM_SERVICE_ERROR_NAMESERVER_NAME_AND_RESOURCE_RANGE_BOTH_DEFINED (RM_SERVICE_ERROR_BASE-13)
-/** Error occurred when trying to add an object to the NameServer */
-#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_ADD_FAILED (RM_SERVICE_ERROR_BASE-14)
-/** Could not find the object specified in the service request in the NameServer */
-#define RM_SERVICE_ERROR_NAMESERVER_ERROR_NAME_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-15)
-
-/**
- * @brief Maximum number of characters in the resource names
- */
-#define RM_RESOURCE_NAME_MAX_CHARS (36)
-
/**
* @brief RM service types
*/
* be returned if the service request is satisfied immediately */
uint32_t serviceId;
/** The name of the resource affected by the service request */
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS];
+ char resourceName[RM_NAME_MAX_CHARS];
/** The base value of the returned resource. In the case of a block resource allocation
* response this field will contain the base value of the block. */
int32_t resourceBase;
} Rm_ServiceReqInfo;
/**
- * @brief RM Service Port provided to software components and applications that
+ * @brief RM Service Handle provided to software components and applications that
* request RM services for the resources they wish to use
*/
typedef struct {
*/
void (*Rm_serviceHandler)(void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
Rm_ServiceRespInfo *serviceResponse);
-} Rm_ServicePort;
+} Rm_ServiceHandle;
/**
* @brief RM pre-main allocation request information provided by the pre-main
@@ -334,8 +211,8 @@ void Rm_servicePreMainRequest(Rm_PreMainReqCfg *reqCfg, Rm_ServiceRespInfo *preM
/**
* @b Description
* @n
- * This function returns a RM service port to the application to
- * provide to software components (LLDs, BIOS, etc) that want to use RM
+ * This function returns a RM service handle to the application to
+ * provide services to software components (LLDs, BIOS, etc) that want to use RM
* for resource management.
*
* @param[in] rmHandle
@@ -343,12 +220,22 @@ void Rm_servicePreMainRequest(Rm_PreMainReqCfg *reqCfg, Rm_ServiceRespInfo *preM
* instance.
*
* @retval
- * Success - RM Service Port. Used by an application or component to
+ * Success - RM Service Handle. Used by an application or component to
* request a service from RM.
* @retval
* Failure - NULL
*/
-Rm_ServicePort *Rm_serviceGetPort(Rm_Handle rmHandle);
+Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result);
+
+/**
+ * @b Description
+ * @n
+ * This function closes a RM instance's service handle
+ *
+ * @param[in] rmServiceHandle
+ * RM instance service handle to be closed.
+ */
+int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle);
/**
@}
}
#endif
-#endif /* RMSERVICES_H_ */
+#endif /* RM_SERVICES_H_ */
diff --git a/rm_transport.h b/rm_transport.h
index 6a961838b82e4b4ebf470a0dd06930c0a2aaf907..4fa569dfe982afee666296df83ebc2a25547c751 100644 (file)
--- a/rm_transport.h
+++ b/rm_transport.h
/**
- * @file rmtransport.h
+ * @file rm_transport.h
*
* @brief
* This is the RM include file for the generic transport interface used by RM to exchange
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-#ifndef RMTRANSPORT_H_
-#define RMTRANSPORT_H_
+#ifndef RM_TRANSPORT_H_
+#define RM_TRANSPORT_H_
#ifdef __cplusplus
extern "C" {
#endif
+/* Standard includes */
+#include <stdbool.h>
+
/* RM includes */
#include <ti/drv/rm/rm.h>
/**
-@addtogroup RMTRANSPORT_API
+@addtogroup RM_TRANSPORT_API
@{
*/
-/** RM Transport Result Return Codes */
-/** RM Transport Success Code Base */
-#define RM_TRANSPORT_OK_BASE (0)
-/** RM transport action was successful. */
-#define RM_TRANSPORT_SUCCESSFUL (RM_TRANSPORT_OK_BASE)
-
-/** RM Transport Error Code Base */
-#define RM_TRANSPORT_ERROR_BASE (-64)
-/** RM transport handle has not been registered with the RM instance */
-#define RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED (RM_TRANSPORT_ERROR_BASE-1)
-/** RM packets are available but an error was encountered during reception */
-#define RM_TRANSPORT_ERROR_PACKET_RECEPTION_ERROR (RM_TRANSPORT_ERROR_BASE-3)
-/** RM received a packet with an unknown RM packet type */
-#define RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE (RM_TRANSPORT_ERROR_BASE-4)
-/** RM resource request transaction could not be found matching the response received */
-#define RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-5)
-/** RM NameServer request transaction could not be found matching the response received */
-#define RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-6)
-
-/**
- * @brief Result of RM transport layer operations
- */
-typedef int32_t Rm_TransportResult;
-
/** Maximum size of the RM transport packet */
-#define RM_TRANSPORT_PACKET_MAX_SIZE_BYTES (256) // Placeholder: This will
- // change during development
+#define RM_TRANSPORT_PACKET_MAX_SIZE_BYTES (256)
/**
* @brief RM transport handle
/** Allocate/Free request packet */
Rm_pktType_RESOURCE_REQUEST = 0,
/** Allocate/Free response packet */
- Rm_pktType_RESOURCE_RESPONSE = 1,
+ Rm_pktType_RESOURCE_RESPONSE,
/** RM NameServer mapping request */
- Rm_pktType_NAMESERVER_REQUEST = 2,
+ Rm_pktType_NAMESERVER_REQUEST,
/** RM NameServer mapping response */
- Rm_pktType_NAMESERVER_RESPONSE = 3,
- /** Policy request packet */
- Rm_pktType_POLICY_REQUEST = 4,
- /** Policy response packet */
- Rm_pktType_POLICY_CHANGE = 5,
- /** Resource pool modification request */
- Rm_pktType_RESOURCE_POOL_MODIFICATION_REQUEST = 6,
- /** Resource pool modification response */
- Rm_pktType_RESOURCE_POOL_MODIFICATION_RESPONSE = 7
+ Rm_pktType_NAMESERVER_RESPONSE
} Rm_pktType;
/**
*/
typedef struct {
/** Packet length in bytes. Written by application when allocated */
- uint32_t pktLenBytes;
+ uint32_t pktLenBytes;
/** Type of RM packet contained in the byte data array */
Rm_pktType pktType;
/** Byte array containing RM packet data */
- char data[RM_TRANSPORT_PACKET_MAX_SIZE_BYTES];
+ char data[RM_TRANSPORT_PACKET_MAX_SIZE_BYTES];
} Rm_Packet;
typedef struct {
* Failure - NULL
*/
Rm_TransportHandle Rm_transportRegister (Rm_TransportCfg *transportCfg, int32_t *result);
-Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle);
+int32_t Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle);
int32_t Rm_receivePktIsr(Rm_TransportHandle transportHandle, Rm_Packet *pkt);
int32_t Rm_receivePktPolling(Rm_TransportHandle transportHandle);
}
#endif
-#endif /* RMTRANSPORT_H_ */
+#endif /* RM_TRANSPORT_H_ */
diff --git a/rm_types.h b/rm_types.h
--- a/rm_types.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- * @file rmtypes.h
- *
- * @brief
- * This is a wrapper header file which includes the standard types
- * used by the RM.
- *
- * \par
- * NOTE:
- * (C) Copyright 2012 Texas Instruments, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the
- * distribution.
- *
- * Neither the name of Texas Instruments Incorporated nor the names of
- * its contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * \par
-*/
-#ifndef __RMTYPES_H__
-#define __RMTYPES_H__
-
-/* c99 include */
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <ctype.h>
-
-#endif /* __RMTYPES_H__ */
-
-
-
diff --git a/rmver.h.xdt b/rmver.h.xdt
index 5ec0c98f09564d514cfcb1b63956f4010e5eb1e3..0e70fe889f3ecc4fb37351e17cd5e31219086e8c 100644 (file)
--- a/rmver.h.xdt
+++ b/rmver.h.xdt
* @brief Resource Manager Version Definitions\r
*\r
* ============================================================\r
- * Copyright (c) Texas Instruments Incorporated 2009-2012\r
+ * Copyright (c) Texas Instruments Incorporated 2012-2013\r
* \r
* Redistribution and use in source and binary forms, with or without \r
* modification, are permitted provided that the following conditions \r
diff --git a/setupenv.bat b/setupenv.bat
index 06b8e61fa17af1549d1bfae09298dfc86b50f1e4..2612c0fdefc561044c293275230434c8eba28613 100644 (file)
--- a/setupenv.bat
+++ b/setupenv.bat
@REM * DESCRIPTION: \r
@REM * Configures and sets up the Build Environment\r
@REM *\r
-@REM * Copyright (C) 2012, Texas Instruments, Inc.\r
+@REM * Copyright (C) 2012-2013, Texas Instruments, Inc.\r
@REM *****************************************************************************\r
\r
@echo ---------------------------------------\r
diff --git a/src/Module.xs b/src/Module.xs
index f81b0c169990a8c081f5478634bdef5d22770f54..69271f5c9516f52e6dd17b92e6b55b4b82037e31 100644 (file)
--- a/src/Module.xs
+++ b/src/Module.xs
* DESCRIPTION:
* This file contains the module specification for the RM source directory.
*
- * Copyright (C) 2012, Texas Instruments, Inc.
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.
*****************************************************************************/
/* Load the library utility. */
diff --git a/src/rm.c b/src/rm.c
index eedda3c0def0fd592df0ad3fb61d7c22fd41a67f..ee73b1f425727bdea6a5082fb13638b3092fa0a8 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
*\r
* \par\r
* ============================================================================\r
- * @n (C) Copyright 2012, Texas Instruments, Inc.\r
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.\r
* \r
* Redistribution and use in source and binary forms, with or without \r
* modification, are permitted provided that the following conditions \r
* \par\r
*/\r
\r
-/* RM Types */\r
-#include <ti/drv/rm/rm_types.h>\r
+/* Standard includes */\r
+#include <stdint.h>\r
+#include <string.h>\r
+#include <stdbool.h>\r
\r
/* RM external includes */\r
#include <ti/drv/rm/rm.h>\r
/**********************************************************************\r
************************** Globals ***********************************\r
**********************************************************************/\r
-extern char rmDtbStartingNode[];\r
+extern const char rmDtbStartingNode[];\r
\r
/** @brief Global Variable which describes the RM Version Information */\r
const char rmVersionStr[] = RM_VERSION_STR ":" __DATE__ ":" __TIME__;\r
\r
Rm_Transaction *rmTransactionQueueAdd(Rm_Inst *rmInst)\r
{\r
- Rm_Transaction *transactionQueue = (Rm_Transaction *)rmInst->transactionQueue;\r
+ Rm_Transaction *transactionQueue = rmInst->transactionQueue;\r
Rm_Transaction *newTransaction = NULL;\r
\r
newTransaction = Rm_osalMalloc(sizeof(Rm_Transaction));\r
\r
Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId)\r
{\r
- Rm_Transaction *transaction = (Rm_Transaction *)rmInst->transactionQueue;\r
+ Rm_Transaction *transaction = rmInst->transactionQueue;\r
\r
if (transaction != NULL) {\r
while (transaction != NULL) {\r
\r
int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)\r
{\r
- Rm_Transaction *transaction = (Rm_Transaction *) rmInst->transactionQueue;\r
+ Rm_Transaction *transaction = rmInst->transactionQueue;\r
Rm_Transaction *prevTransaction = NULL;\r
int32_t retVal = RM_SERVICE_STATE_OKAY;\r
\r
\r
Rm_Allocator *rmAllocatorAdd(Rm_Inst *rmInst, const char *resourceName)\r
{\r
- Rm_Allocator *allocators = (Rm_Allocator *)rmInst->allocators;\r
+ Rm_Allocator *allocators = rmInst->allocators;\r
Rm_Allocator *newAllocator = NULL;\r
\r
newAllocator = Rm_osalMalloc(sizeof(Rm_Allocator));\r
\r
if (newAllocator) {\r
memset((void *)newAllocator, 0, sizeof(Rm_Allocator));\r
- strncpy(newAllocator->resourceName, resourceName, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(newAllocator->resourceName, resourceName, RM_NAME_MAX_CHARS);\r
newAllocator->allocatorRootEntry = NULL;\r
newAllocator->nextAllocator = NULL; \r
\r
\r
int32_t rmAllocatorDelete(Rm_Inst *rmInst, char *resourceName)\r
{\r
- Rm_Allocator *allocator = (Rm_Allocator *) rmInst->allocators;\r
+ Rm_Allocator *allocator = rmInst->allocators;\r
Rm_Allocator *prevAllocator = NULL;\r
int32_t retVal = RM_SERVICE_STATE_OKAY;\r
\r
@@ -562,7 +564,6 @@ int32_t rmTreeAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourc
allocPassesPolicy = TRUE;\r
}\r
else {\r
- allocPassesPolicy = FALSE;\r
policyCheckCfg.policyDtb = rmInst->policy;\r
policyCheckCfg.resourceOffset = resourcePolicy; \r
policyCheckCfg.type = policyCheckType;\r
@@ -749,7 +750,7 @@ int32_t rmTreeAllocate(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourc
return(retVal); \r
}\r
\r
-int32_t rmTreeFree(Rm_Inst *rmInst, Rm_Allocator *allocator, int32_t resourcePolicy, Rm_AllocatorOpInfo *opInfo)\r
+int32_t rmTreeFree(Rm_Allocator *allocator, Rm_AllocatorOpInfo *opInfo)\r
{\r
Rm_ResourceNode findNode;\r
Rm_ResourceNode *matchingNode = NULL;\r
retVal = rmTreeAllocate(rmInst, allocator, resourceOffsetInPolicy, opInfo);\r
}\r
else if (opInfo->operation == Rm_allocatorOp_FREE) {\r
- retVal = rmTreeFree(rmInst, allocator, resourceOffsetInPolicy, opInfo);\r
+ retVal = rmTreeFree(allocator, opInfo);\r
} \r
}\r
else {\r
@@ -997,7 +998,7 @@ void rmAllocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *va
nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;\r
if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {\r
- strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
} \r
@@ -1053,7 +1054,7 @@ void rmFreeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction, void *validIns
nameServerObjCfg.nameServerTree = rmInst->nameServer;\r
nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;\r
if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {\r
- strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
} \r
(transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||\r
(transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))\r
{\r
- strncpy(serviceResponse.resourceName, transaction->resourceInfo.name, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(serviceResponse.resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);\r
serviceResponse.resourceBase = transaction->resourceInfo.base;\r
serviceResponse.resourceLength = transaction->resourceInfo.length;\r
}\r
else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {\r
if ((transaction->state = rmNameServerFindObject(&nameServerObjCfg)) ==\r
RM_SERVICE_PROCESSING) {\r
- strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);\r
transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;\r
transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;\r
transaction->state = RM_SERVICE_APPROVED_AND_COMPLETED;\r
@@ -1363,7 +1364,7 @@ int32_t rmFindAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName,
memset((void *) &opInfo, 0, sizeof(Rm_AllocatorOpInfo));\r
memset((void *) &resourceInfo, 0, sizeof(Rm_ResourceInfo));\r
\r
- strncpy(resourceInfo.name, resourceName, RM_RESOURCE_NAME_MAX_CHARS);\r
+ strncpy(resourceInfo.name, resourceName, RM_NAME_MAX_CHARS);\r
opInfo.serviceSrcInstNode = rmPolicyGetLinuxInstNode(rmInst->validInstances);\r
opInfo.operation = Rm_allocatorOp_ALLOCATE;\r
opInfo.resourceInfo = &resourceInfo; \r
@@ -1693,7 +1694,7 @@ Rm_PreMainHandle Rm_preMainInit(Rm_PreMainInitCfg *preMainInitCfg, int32_t *resu
{\r
Rm_PreMainInst *preMainInst;\r
\r
- if ((strlen(preMainInitCfg->instName) + 1) > RM_INSTANCE_NAME_MAX_CHARS) {\r
+ if ((strlen(preMainInitCfg->instName) + 1) > RM_NAME_MAX_CHARS) {\r
*result = RM_INIT_ERROR_INSTANCE_NAME_TOO_BIG;\r
return (NULL);\r
}\r
@@ -1717,7 +1718,7 @@ Rm_PreMainHandle Rm_preMainInit(Rm_PreMainInitCfg *preMainInitCfg, int32_t *resu
preMainInst = NULL;\r
}\r
else {\r
- strncpy(preMainInst->instName, preMainInitCfg->instName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(preMainInst->instName, preMainInitCfg->instName, RM_NAME_MAX_CHARS);\r
preMainInst->requestCount = 0;\r
preMainInst->preMainReqList = NULL;\r
}\r
\r
*result = RM_INIT_OK;\r
\r
- if ((strlen(initCfg->instName) + 1) > RM_INSTANCE_NAME_MAX_CHARS) {\r
+ if ((strlen(initCfg->instName) + 1) > RM_NAME_MAX_CHARS) {\r
*result = RM_INIT_ERROR_INSTANCE_NAME_TOO_BIG;\r
return (NULL);\r
}\r
/* Create and initialize instance */\r
rmInst = Rm_osalMalloc (sizeof(Rm_Inst));\r
memset ((void *) rmInst, 0, sizeof(Rm_Inst));\r
- strncpy (rmInst->instName, initCfg->instName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy (rmInst->instName, initCfg->instName, RM_NAME_MAX_CHARS);\r
rmInst->instType = initCfg->instType;\r
+ rmInst->serviceHandle = NULL;\r
rmInst->registeredWithDelegateOrServer = false;\r
rmInst->transports = NULL;\r
rmInst->allocators = NULL;\r
diff --git a/src/rm_dtb_util.c b/src/rm_dtb_util.c
index 37f658fa9de9f3a09d3ae7d7f8874596ef2c5144..9bd024ce0507422853e8ee7c32650e017064c753 100644 (file)
--- a/src/rm_dtb_util.c
+++ b/src/rm_dtb_util.c
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-/* RM Types */
-#include <ti/drv/rm/rm_types.h>
-
/* RM external API includes */
#include <ti/drv/rm/rm.h>
-#include <ti/drv/rm/rm_services.h>
/* RM internal API includes */
#include <ti/drv/rm/include/rm_dtb_utilloc.h>
********************Common DTB Parsing Functions**********************
**********************************************************************/
-char rmDtbStartingNode[] = "\0";
+const char rmDtbStartingNode[] = "\0";
/* Construct and return a list of ranges as specified in either the Resource
* DTB or a Policy DTB */
@@ -311,7 +307,7 @@ Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t
newAssignment = (Rm_NsAssignment *) Rm_osalMalloc(sizeof(Rm_NsAssignment));
nameLenBytes = strlen((char *) &dtbNsAssignmentData[i]) + 1;
- if (nameLenBytes > RM_RESOURCE_NAME_MAX_CHARS) {
+ if (nameLenBytes > RM_NAME_MAX_CHARS) {
Rm_osalFree((void *)newAssignment, sizeof(Rm_NsAssignment));
while (startAssignment) {
newAssignment = startAssignment->nextNsAssignment;
@@ -321,7 +317,7 @@ Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t
*result = RM_INIT_ERROR_NS_ASSIGNMENT_NAME_TOO_LONG;
return(NULL);
}
- strncpy(newAssignment->nsName, ((char *) &dtbNsAssignmentData[i]), RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(newAssignment->nsName, ((char *) &dtbNsAssignmentData[i]), RM_NAME_MAX_CHARS);
/* Extract 32-bit base value and flip endian */
i += nameLenBytes;
@@ -498,7 +494,7 @@ Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
newInst = (Rm_PolicyValidInst *) Rm_osalMalloc(sizeof(Rm_PolicyValidInst));
instLenBytes = strlen((char *) &dtbValidInstData[i]) + 1;
- if (instLenBytes > RM_INSTANCE_NAME_MAX_CHARS) {
+ if (instLenBytes > RM_NAME_MAX_CHARS) {
Rm_osalFree((void *)newInst, sizeof(Rm_PolicyValidInst));
while (startInst) {
newInst = startInst->nextValidInst;
diff --git a/src/rm_nameserver.c b/src/rm_nameserver.c
index ce3ab592e41d8396680db15f045d22fc5357109f..c4a9e1a7270fa6085c56832ec3ba3da55d73d723 100644 (file)
--- a/src/rm_nameserver.c
+++ b/src/rm_nameserver.c
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-/* RM Types */
-#include <ti/drv/rm/rm_types.h>
+/* Standard includes */
+#include <string.h>
/* RM external API includes */
-#include <ti/drv/rm/rm_services.h>
+#include <ti/drv/rm/rm.h>
/* RM internal API includes */
#include <ti/drv/rm/include/rm_nameserverloc.h>
int32_t retVal = RM_SERVICE_ERROR_NAMESERVER_ERROR_NAME_DOES_NOT_EXIST;
memset((void *)&findNode, 0, sizeof(Rm_NameServerNode));
- strncpy(findNode.objName, objCfg->nodeCfg.objName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(findNode.objName, objCfg->nodeCfg.objName, RM_NAME_MAX_CHARS);
if (matchingNode = RB_FIND(_Rm_NameServerTree, objCfg->nameServerTree, &findNode)) {
/* Found in NameServer */
int32_t retVal = RM_SERVICE_ERROR_NAMESERVER_ERROR_NAME_DOES_NOT_EXIST;
memset((void *)&findNode, 0, sizeof(Rm_NameServerNode));
- strncpy(findNode.objName, objCfg->nodeCfg.objName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(findNode.objName, objCfg->nodeCfg.objName, RM_NAME_MAX_CHARS);
if (matchingNode = RB_FIND(_Rm_NameServerTree, objCfg->nameServerTree, &findNode)) {
/* Remove from NameServer */
diff --git a/src/rm_policy.c b/src/rm_policy.c
index c9d97c8639d7c862db43668603e7c2544f7280c1..b49582b6d748debd1e7355ffb7e605c74b127418 100644 (file)
--- a/src/rm_policy.c
+++ b/src/rm_policy.c
/**
- * @file rmpolicy.c
+ * @file rm_policy.c
*
* @brief
* Resource Manager Policy source.
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-/* RM Types */
-#include <ti/drv/rm/rm_types.h>
+/* Standard includes */
+#include <ctype.h>
/* RM external API includes */
#include <ti/drv/rm/rm.h>
-#include <ti/drv/rm/rm_services.h>
/* RM internal API includes */
#include <ti/drv/rm/include/rm_loc.h>
*********************** Policy Globals *******************************
**********************************************************************/
-char Rm_policyAllInstances[] = "*";
+const char Rm_policyAllInstances[] = "*";
/**********************************************************************
******************** Local Policy Functions **************************
@@ -90,16 +89,16 @@ Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrE
Rm_PolicyPermission *newPerm = NULL;
Rm_PolicyPermission *prevPerm = NULL;
Rm_PolicyPermission *nextPerm = NULL;
- char *permStrPtr = NULL;
- char *subgroupStart = NULL;
- char *subgroupEnd = NULL;
- uint32_t permStrLen = (uint32_t)(permStrEnd - permStrStart + 1);
- char instNameTemp[RM_INSTANCE_NAME_MAX_CHARS];
- uint32_t instNameIndex;
- bool foundInstName;
- bool instNameComplete;
- bool assignmentLeft;
- bool assignmentRight;
+ char *permStrPtr = NULL;
+ char *subgroupStart = NULL;
+ char *subgroupEnd = NULL;
+ uint32_t permStrLen = (uint32_t)(permStrEnd - permStrStart + 1);
+ char instNameTemp[RM_NAME_MAX_CHARS];
+ uint32_t instNameIndex;
+ bool foundInstName;
+ bool instNameComplete;
+ bool assignmentLeft;
+ bool assignmentRight;
/* Create a local copy of the sub-permission string */
permStrPtr = Rm_osalMalloc(permStrLen);
@@ -116,8 +115,7 @@ Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrE
if ((!subgroupStart) || (!subgroupEnd) || (subgroupStart > subgroupEnd) ||
((subgroupStart != strrchr(permStrStart, RM_POLICY_PERM_SUBGROUP_START)) &&
- (subgroupEnd != strrchr(permStrStart, RM_POLICY_PERM_SUBGROUP_END))))
- {
+ (subgroupEnd != strrchr(permStrStart, RM_POLICY_PERM_SUBGROUP_END)))) {
/* Free the memory associated with the temp string and return an error if:
* a) Could not find the instance group start
* b) Could not find the instance group end
@@ -159,7 +157,7 @@ Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrE
newPerm = (Rm_PolicyPermission *) Rm_osalMalloc(sizeof(Rm_PolicyPermission));
memset((void *)newPerm, 0, sizeof(Rm_PolicyPermission));
- strncpy(newPerm->instName, instNameTemp, RM_INSTANCE_NAME_MAX_CHARS);
+ strncpy(newPerm->instName, instNameTemp, RM_NAME_MAX_CHARS);
newPerm->nextPermission = NULL;
if (prevPerm == NULL) {
@@ -175,7 +173,7 @@ Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrE
instNameIndex = 0;
foundInstName = FALSE;
}
- else if (instNameIndex == RM_INSTANCE_NAME_MAX_CHARS) {
+ else if (instNameIndex == RM_NAME_MAX_CHARS) {
/* Instance name is longer than max length */
while (startPerm) {
nextPerm = startPerm->nextPermission;
@@ -400,10 +398,10 @@ Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *assignm
Rm_PolicyPermission *startPerm = NULL;
Rm_PolicyPermission *newPerm = NULL;
Rm_PolicyPermission *prevPerm = NULL;
- char *permStrStart = assignment->permissionsList;
- char *permStrEnd;
- uint32_t permStrLen = strlen(assignment->permissionsList) + 1;
- uint32_t i = 0;
+ char *permStrStart = assignment->permissionsList;
+ char *permStrEnd;
+ uint32_t permStrLen = strlen(assignment->permissionsList) + 1;
+ uint32_t i = 0;
while(i < permStrLen) {
/* Find the first sub-permission specification and parse it. A sub-permission
{
Rm_PolicyAssignment *assignment = assignmentList;
Rm_PolicyPermission *permissionList;
- int32_t result;
+ int32_t result;
while (assignment) {
/* Make sure assignment's permissions parse okay */
@@ -480,7 +478,7 @@ Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_PolicyValidInstTree *validIn
Rm_PolicyValidInstNode findNode;
memset((void *)&findNode, 0, sizeof(Rm_PolicyValidInstNode));
- strncpy(findNode.name, instName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(findNode.name, instName, RM_NAME_MAX_CHARS);
return (RB_FIND(_Rm_PolicyValidInstTree, validInstTree, &findNode));
}
int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList)
{
Rm_Allocator *allocator = (Rm_Allocator *)allocatorList;
- int32_t nodeOffset;
- int32_t depth;
- const char *nodeName;
+ int32_t nodeOffset;
+ int32_t depth;
+ const char *nodeName;
depth = RM_DTB_UTIL_STARTING_DEPTH;
nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;
diff --git a/src/rm_services.c b/src/rm_services.c
index 3033b9186b651bec02549a595404ea780fa894eb..441f94720c6d04e6d180ff333702e2750c34b7b8 100644 (file)
--- a/src/rm_services.c
+++ b/src/rm_services.c
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* \par
*/
-/* RM Types */
-#include <ti/drv/rm/rm_types.h>
+/* Standard includes */
+#include <string.h>
/* RM external API includes */
#include <ti/drv/rm/rm_services.h>
transaction = rmTransactionQueueAdd(rmInst);
if (transaction) {
transaction->type = serviceRequest->type;
- strncpy(transaction->serviceSrcInstName, rmInst->instName, RM_INSTANCE_NAME_MAX_CHARS);
+ strncpy(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
transaction->callback.serviceCallback = serviceRequest->callback.serviceCallback;
transaction->state = RM_SERVICE_PROCESSING;
if (serviceRequest->resourceName) {
- strncpy(transaction->resourceInfo.name, serviceRequest->resourceName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(transaction->resourceInfo.name, serviceRequest->resourceName, RM_NAME_MAX_CHARS);
}
transaction->resourceInfo.base = serviceRequest->resourceBase;
transaction->resourceInfo.length = serviceRequest->resourceLength;
transaction->resourceInfo.alignment = serviceRequest->resourceAlignment;
if (serviceRequest->resourceNsName) {
- strncpy(transaction->resourceInfo.nameServerName, serviceRequest->resourceNsName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(transaction->resourceInfo.nameServerName, serviceRequest->resourceNsName, RM_NAME_MAX_CHARS);
}
rmTransactionProcessor (rmInst, transaction);
if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
(transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
(transaction->type == Rm_service_RESOURCE_GET_BY_NAME)) {
- strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
serviceResponse->resourceBase = transaction->resourceInfo.base;
serviceResponse->resourceLength = transaction->resourceInfo.length;
}
@@ -174,30 +174,48 @@ void Rm_servicePreMainRequest(Rm_PreMainReqCfg *reqCfg, Rm_ServiceRespInfo *preM
/* Fill out response */
preMainResp->resourceBase = reqCfg->request->resourceBase;
preMainResp->resourceLength = reqCfg->request->resourceLength;
- strncpy(preMainResp->resourceName, reqCfg->request->resourceName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(preMainResp->resourceName, reqCfg->request->resourceName, RM_NAME_MAX_CHARS);
preMainResp->serviceId = ++preMainInst->requestCount;
}
}
-Rm_ServicePort *Rm_serviceGetPort(Rm_Handle rmHandle)
+Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result)
{
- Rm_ServicePort *newServicePort = NULL;
-
- /* Create a new service handle for the specified RM instance */
-
- /* Get memory for a new service port from local memory */
- newServicePort = Rm_osalMalloc (sizeof(Rm_ServicePort));
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_ServiceHandle *newServiceHandle = NULL;
- /* Return NULL immediately if malloc returned NULL */
- if (newServicePort == NULL)
- {
- return (newServicePort);
+ *result = RM_INIT_OK;
+
+ if (rmInst->serviceHandle == NULL) {
+ newServiceHandle = Rm_osalMalloc (sizeof(Rm_ServiceHandle));
+ if (newServiceHandle) {
+ newServiceHandle->rmHandle = rmHandle;
+ newServiceHandle->Rm_serviceHandler = Rm_serviceHandler;
+ rmInst->serviceHandle = newServiceHandle;
+ }
+ else {
+ *result = RM_INIT_ERROR_SERVICE_HANDLE_MEMORY_ALLOC_FAILED;
+ }
}
+ else {
+ *result = RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_ALLOCATED;
+ }
+ return (newServiceHandle);
+}
- newServicePort->rmHandle = rmHandle;
- newServicePort->Rm_serviceHandler = Rm_serviceHandler;
+int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle)
+{
+ Rm_Inst *rmInst = (Rm_Inst *)rmServiceHandle->rmHandle;
+ int32_t retVal = RM_INIT_OK;
- return (newServicePort);
+ if (rmInst->serviceHandle) {
+ Rm_osalFree((void *)rmServiceHandle, sizeof(Rm_ServiceHandle));
+ rmInst->serviceHandle = NULL;
+ }
+ else {
+ retVal = RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_CLOSED_FOR_INSTANCE;
+ }
+ return(retVal);
}
/**
diff --git a/src/rm_transport.c b/src/rm_transport.c
index 5e255ead4f286bc0b92b9a830e665394f92fbb61..8f0fa5529a00f1c4021ec1a7dd1f89c6abe9d7dc 100644 (file)
--- a/src/rm_transport.c
+++ b/src/rm_transport.c
*\r
* \par\r
* ============================================================================\r
- * @n (C) Copyright 2012, Texas Instruments, Inc.\r
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.\r
* \r
* Redistribution and use in source and binary forms, with or without \r
* modification, are permitted provided that the following conditions \r
* \par\r
*/\r
\r
-/* RM Types */\r
-#include <ti/drv/rm/rm_types.h>\r
+/* Standard includes */\r
+#include <string.h>\r
\r
/* RM external includes */\r
#include <ti/drv/rm/rm.h>\r
if (newTransport) {\r
newTransport->rmHandle = transportCfg->rmHandle;\r
newTransport->remoteInstType = transportCfg->remoteInstType;\r
- strncpy(&(newTransport->remoteInstName)[0], transportCfg->remoteInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(&(newTransport->remoteInstName)[0], transportCfg->remoteInstName, RM_NAME_MAX_CHARS);\r
newTransport->nextTransport = NULL;\r
\r
if (transports) {\r
return (transports);\r
}\r
\r
-Rm_TransportResult transportDelete(Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
+int32_t transportDelete(Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
{\r
Rm_Inst *rmInst = (Rm_Inst *)rmHandle;\r
Rm_Transport *transport = (Rm_Transport *) rmInst->transports;\r
@@ -179,8 +179,8 @@ Rm_Packet *rmTransportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_Transport *dstTra
else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {\r
resourceReqPkt->resourceReqType = Rm_resReqPktType_GET_NAMED;\r
}\r
- strncpy(resourceReqPkt->pktSrcInstName, rmInst->instName, RM_INSTANCE_NAME_MAX_CHARS);\r
- strncpy(resourceReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(resourceReqPkt->pktSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);\r
+ strncpy(resourceReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
memcpy ((void *)&(resourceReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
sizeof(Rm_ResourceInfo));\r
return (rmPkt);\r
@@ -239,8 +239,8 @@ Rm_Packet *rmTransportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_Transport *dstTrans
else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {\r
nsReqPkt->nsRequestType = Rm_nsReqPktType_UNMAP_RESOURCE;\r
}\r
- strncpy(nsReqPkt->pktSrcInstName, rmInst->instName, RM_INSTANCE_NAME_MAX_CHARS);\r
- strncpy(nsReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(nsReqPkt->pktSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);\r
+ strncpy(nsReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
memcpy ((void *)&(nsReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
sizeof(Rm_ResourceInfo));\r
\r
@@ -329,12 +329,12 @@ Rm_TransportHandle Rm_transportRegister (Rm_TransportCfg *transportCfg, int32_t
return ((Rm_TransportHandle) transport);\r
}\r
\r
-Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
+int32_t Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandle transportHandle)\r
{\r
- Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
- Rm_Transport *transport = transportFindTransportHandle((Rm_Transport *)rmInst->transports, \r
+ Rm_Inst *rmInst = (Rm_Inst *) rmHandle;\r
+ Rm_Transport *transport = transportFindTransportHandle((Rm_Transport *)rmInst->transports, \r
transportHandle);\r
- Rm_TransportResult retVal = RM_TRANSPORT_SUCCESSFUL; \r
+ int32_t retVal = RM_TRANSPORT_SUCCESSFUL; \r
\r
if (transport == NULL) {\r
retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_GET_NAMED) {\r
transaction->type = Rm_service_RESOURCE_GET_BY_NAME;\r
} \r
- strncpy(transaction->pktSrcInstName, resourceReqPkt->pktSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
- strncpy(transaction->serviceSrcInstName, resourceReqPkt->serviceSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(transaction->pktSrcInstName, resourceReqPkt->pktSrcInstName, RM_NAME_MAX_CHARS);\r
+ strncpy(transaction->serviceSrcInstName, resourceReqPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
transaction->state = RM_SERVICE_PROCESSING;\r
memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceReqPkt->resourceInfo),\r
sizeof(Rm_ResourceInfo));\r
transaction->type = Rm_service_RESOURCE_UNMAP_NAME;\r
}\r
\r
- strncpy(transaction->pktSrcInstName, nsRequestPkt->pktSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
- strncpy(transaction->serviceSrcInstName, nsRequestPkt->serviceSrcInstName, RM_INSTANCE_NAME_MAX_CHARS);\r
+ strncpy(transaction->pktSrcInstName, nsRequestPkt->pktSrcInstName, RM_NAME_MAX_CHARS);\r
+ strncpy(transaction->serviceSrcInstName, nsRequestPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
transaction->state = RM_SERVICE_PROCESSING;\r
memcpy ((void *)&(transaction->resourceInfo), (void *)&(nsRequestPkt->resourceInfo),\r
sizeof(Rm_ResourceInfo));\r
}\r
break;\r
}\r
- case Rm_pktType_POLICY_REQUEST:\r
- {\r
- Rm_PolicyRequestPkt *policyRequestPkt = (Rm_PolicyRequestPkt *)pkt->data;\r
-\r
- /* TODO: FILL IN POLICY API INFORMATION */\r
- break; \r
- }\r
- case Rm_pktType_POLICY_CHANGE:\r
- {\r
- Rm_PolicyChangePkt *policyChangePkt = (Rm_PolicyChangePkt *)pkt->data;\r
-\r
- /* TODO: FILL IN POLICY API INFORMATION */\r
- break;\r
- }\r
- case Rm_pktType_RESOURCE_POOL_MODIFICATION_REQUEST:\r
- {\r
- Rm_ResourcePoolModRequestPkt *resPoolModReqPkt = (Rm_ResourcePoolModRequestPkt *)pkt->data;\r
-\r
- /* TODO: FILL IN RESOURCE POOL MODIFICATION API */\r
- /* Rm_resourcePoolModRequestHandler(...); Server only - needs to allocate resources to\r
- * the Client Delegate based on the policy and return those resources to the Client Delegate */\r
- break;\r
- }\r
- case Rm_pktType_RESOURCE_POOL_MODIFICATION_RESPONSE:\r
- {\r
- Rm_ResourcePoolModResponsePkt *resPoolModRespPkt = (Rm_ResourcePoolModResponsePkt *)pkt->data;\r
-\r
- /* TODO: FILL IN RESOURCE POOL MODIFICAITON API */\r
- /* Rm_resourcePoolModResponseHandler(...); Handler needs to populate allocator with\r
- * new resources provided in the response and then handle any request transactions waiting on\r
- * the resource pool modification */\r
- break;\r
- }\r
default:\r
rmInst->transport.rmFreePkt(transportHandle, pkt);\r
return (RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE);\r
diff --git a/src/rm_tree.c b/src/rm_tree.c
index cab252ed029973219926fee63dbe6de1063ad2ef..cb9519c640cac67e98be7fffa943bda57d1e5c69 100644 (file)
--- a/src/rm_tree.c
+++ b/src/rm_tree.c
* \par
*/
-/* RM Types */
-#include <ti/drv/rm/rm_types.h>
+/* Standard includes */
+#include <string.h>
+
+/* RM external API includes */
+#include <ti/drv/rm/rm.h>
/* RM internal API includes */
#include <ti/drv/rm/include/rm_treeloc.h>
newNode = Rm_osalMalloc(sizeof(Rm_NameServerNode));
if (newNode) {
- strncpy(newNode->objName, nodeCfg->objName, RM_RESOURCE_NAME_MAX_CHARS);
- strncpy(newNode->resourceName, nodeCfg->resourceName, RM_RESOURCE_NAME_MAX_CHARS);
+ strncpy(newNode->objName, nodeCfg->objName, RM_NAME_MAX_CHARS);
+ strncpy(newNode->resourceName, nodeCfg->resourceName, RM_NAME_MAX_CHARS);
newNode->resourceBase = nodeCfg->resourceBase;
newNode->resourceLength = nodeCfg->resourceLength;
}
newNode = Rm_osalMalloc(sizeof(Rm_PolicyValidInstNode));
- strncpy(newNode->name, instName, RM_INSTANCE_NAME_MAX_CHARS);
+ strncpy(newNode->name, instName, RM_NAME_MAX_CHARS);
newNode->allocRefCount = 0;
newNode->deletePending = FALSE;
}
/* Generate the red-black tree manipulation functions */
-RB_GENERATE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, resourceNodeCompare);
+RB_GENERATE(_Rm_AllocatorResourceTree, _Rm_ResourceNode, linkage, resourceNodeCompare)
diff --git a/test/Module.xs b/test/Module.xs
index 7a4b78e06dadc295d5baa39defd8b1d35ceed048..a780898aa17506f8ac2c7a7eb83ca0081ce17329 100644 (file)
--- a/test/Module.xs
+++ b/test/Module.xs
* DESCRIPTION:
* This file contains the module specification for RM test files.
*
- * Copyright (C) 2012, Texas Instruments, Inc.
+ * Copyright (C) 2012-2013, Texas Instruments, Inc.
*****************************************************************************/
/* Load the library utility. */
diff --git a/test/rm_osal.c b/test/rm_osal.c
index e8c1856fd349a3cfe705ccd3f4636b292a74d332..258eb47c029408a2bc36570d6496cba518bf3bef 100644 (file)
--- a/test/rm_osal.c
+++ b/test/rm_osal.c
*
* \par
* ============================================================================
- * @n (C) Copyright 2012, Texas Instruments, Inc.
+ * @n (C) Copyright 2012-2013, Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
diff --git a/test/rm_osal.h b/test/rm_osal.h
index 1f765151f0bfc6c4f5b74a2e0c95ad844841ae6f..a255a001ad69b983323d5d1bf33f6368b187f6f3 100644 (file)
--- a/test/rm_osal.h
+++ b/test/rm_osal.h
*
* \par
* NOTE:
- * (C) Copyright 2009 Texas Instruments, Inc.
+ * (C) Copyright 2012-2013 Texas Instruments, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
diff --git a/test/rm_test.c b/test/rm_test.c
index 746dd8d72e1ff3cb751b09980fbae09a82bbb4d4..a72f39722f22f5b4fb7f42975f6ce30170fe7cbc 100644 (file)
--- a/test/rm_test.c
+++ b/test/rm_test.c
#define MSGQ_HEAP_ID 0
/* ======== RM Instance Names ======== */
-Char rmServerName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Server";
-Char rmClientDelegateName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client_Delegate";
-Char rmClientName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client";
+Char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server";
+Char rmClientDelegateName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate";
+Char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
/* ======== RM IPC MessageQ Names ======== */
Char serverCdQueueName[30] = "RM_Server_CD_Queue";
Rm_Handle rmClientHandle = NULL;
/* ======== RM Instance Service Ports ======== */
-Rm_ServicePort *rmServerServicePort = NULL;
-Rm_ServicePort *rmClientDelegateServicePort = NULL;
-Rm_ServicePort *rmClientServicePort = NULL;
+Rm_ServiceHandle *rmServerServiceHandle = NULL;
+Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
+Rm_ServiceHandle *rmClientServiceHandle = NULL;
/* ======== RM Transport Packet Definition ======== */
typedef struct {
void testRmTsk(UArg arg0, UArg arg1)
{
Rm_ServiceReqInfo requestInfo;
- Task_Params taskParams;
+ Task_Params taskParams;
+ int32_t result;
/* Delete the RM startup task */
System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
* RM instances */
if (MultiProc_self() == 0)
{
- rmServerServicePort = Rm_serviceGetPort(rmServerHandle);
+ rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
}
else if (MultiProc_self() == 1)
{
- rmClientDelegateServicePort = Rm_serviceGetPort(rmClientDelegateHandle);
- rmClientServicePort = Rm_serviceGetPort(rmClientHandle);
+ rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result);
+ rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
}
memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
/* Use the service ports to test the service requests */
if (MultiProc_self() == 0)
{
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "gp-queue";
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "My_Favorite_Queue";
-
- char aifName[RM_RESOURCE_NAME_MAX_CHARS] = "aif-rx-ch";
- char memRegionName[RM_RESOURCE_NAME_MAX_CHARS] = "memory-regions";
-
+ char resourceName[RM_NAME_MAX_CHARS] = "gp-queue";
+ char resourceNsName[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
+ char aifName[RM_NAME_MAX_CHARS] = "aif-rx-ch";
+ char memRegionName[RM_NAME_MAX_CHARS] = "memory-regions";
/* Issue the service request create a new NameServer object via the service port */
requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
- rmServerServicePort->Rm_serviceHandler(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
}
else if (MultiProc_self() == 1)
{
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "My_Favorite_Queue";
+ char resourceNsName[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
- char aifName[RM_RESOURCE_NAME_MAX_CHARS] = "aif-rx-ch";
- char accumChName[RM_RESOURCE_NAME_MAX_CHARS] = "accumulator-ch";
+ char aifName[RM_NAME_MAX_CHARS] = "aif-rx-ch";
+ char accumChName[RM_NAME_MAX_CHARS] = "accumulator-ch";
/* Issue the service request for the resources tied to the name via the service port */
requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME;
System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
rmClientDelegateName);
- rmClientDelegateServicePort->Rm_serviceHandler(rmClientDelegateServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
rmClientName,
resourceNsName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
- rmClientDelegateServicePort->Rm_serviceHandler(rmClientDelegateServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
- rmClientDelegateServicePort->Rm_serviceHandler(rmClientDelegateServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
requestInfo.callback.serviceCallback = testServiceCallback;
System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
- rmClientServicePort->Rm_serviceHandler(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
if (blockForResponse(&responseInfo))
{
System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
diff --git a/test/rm_test.cfg b/test/rm_test.cfg
index 7dab9cc419091bd095808a390b2a8019fddc23a3..cc7c4a32e3937487fecfc0c0aaeaa7898e936119 100644 (file)
--- a/test/rm_test.cfg
+++ b/test/rm_test.cfg
/*
- * Copyright (c) 2012, Texas Instruments Incorporated
+ * Copyright (c) 2012-2013, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without