Ready for Alpha release
[keystone-rtos/rm-lld.git] / rm.h
1 /**
2  *   @file  rm.h
3  *
4  *   @brief   
5  *      This is the Resource Manager include file.
6  *
7  *  \par
8  *  ============================================================================
9  *  @n   (C) Copyright 2012-2013, Texas Instruments, Inc.
10  * 
11  *  Redistribution and use in source and binary forms, with or without 
12  *  modification, are permitted provided that the following conditions 
13  *  are met:
14  *
15  *    Redistributions of source code must retain the above copyright 
16  *    notice, this list of conditions and the following disclaimer.
17  *
18  *    Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the 
20  *    documentation and/or other materials provided with the   
21  *    distribution.
22  *
23  *    Neither the name of Texas Instruments Incorporated nor the names of
24  *    its contributors may be used to endorse or promote products derived
25  *    from this software without specific prior written permission.
26  *
27  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
28  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
29  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
31  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
32  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
33  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
36  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
37  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38  *
39  *  \par
40 */
42 #ifndef RM_H_
43 #define RM_H_
45 #ifdef __cplusplus
46 extern "C" {
47 #endif
49 /* Standard includes */
50 #include <stdint.h>
52 /* RM version */
53 #include <ti/drv/rm/rmver.h>
55 /**  @mainpage Resource Manager
56  *
57  *   @section intro  Introduction
58  *
59  *   The Resource Manager (RM) is designed to provide an easy to use, extensible
60  *   uinified resource management solution on TI devices.  RM can be integrated by 
61  *   a system application to provide resource management services to the system 
62  *   temporally (pre-main/post-main) and spatially (system subcomponents, task,
63  *   cores).
64  *
65  *   The RM architecture is instance based.  All RM resource management services 
66  *   must originate from a RM instance.  Resource permissions are assigned by a 
67  *   system integrator using RM instance names provided during the initialization
68  *   of each RM instance in use.  There are three types of RM instances, all of
69  *   which can be used by the system to request resource management services:
70  *    - Server - Manages all resource data structures including the resource
71  *               allocators, the permissions policies, and a simple NameServer.
72  *               There can only be one Server per RM ecosystem.  If two Servers
73  *               are initialized within a system they must manage mutually
74  *               exclusive sets of device resources.  There is no limit to the 
75  *               number of Client and Client Delegate instances that can connect
76  *               to the Server
77  *    - Client - Used by system components to request resource services.  There is
78  *               no limit to the number of Clients a system can have.  Client
79  *               names must be unique since resource permissions are assigned based
80  *               on RM instance names.  Clients can connect to at most one Server
81  *               or Client Delegate, but not both at the same time.
82  *    - Client Delegate (CD) - At the moment the CD is not different from the
83  *                             Client.  However, in the future the CD will be able
84  *                             to act as a proxy for the Server.  The CD will be
85  *                             able to satisfy some service requests from Clients,
86  *                             offloading some processing from the Server.  This 
87  *                             feature will be helpful in situations where a
88  *                             slower data path exists between the Server and
89  *                             CD/Client instances.  There is no limit to the number
90  *                             of Clients that can connect to a CD.  The CD can
91  *                             connect to at most one Server.
92  *
93  *   RM instances communicate via a generic transport interface.  The RM transport
94  *   interface expects the application to configure and manage the transport data paths
95  *   between RM instances.  This allows RM to easily extend to different device 
96  *   configurations and different devices entirely.
97  *
98  *   RM utilizes the BDS-licensed, open source, Flattened Device Tree format to 
99  *   specify what resources are managed by RM as well as the RM instance permissions
100  *   for managed resources.  The Global Resource List or GRL defines all device 
101  *   resources and their ranges that will be tracked by the RM Server.  Addition or 
102  *   subtraction of resources from RM requires one modify only the GRL.  RM source code
103  *   changes are not required to add or subtract resources from RM's umbrella of 
104  *   management.  RM Policies specify resource permissions for the RM instances.  There
105  *   are two types of Policies:
106  *    - Global Policy - Provided to the Server at initialization and defines the 
107  *                      resource permissions for all RM instances in the system.
108  *                      All service requests will be validated against the Global
109  *                      Policy on the Server.  If the RM instance is found to not
110  *                      hold the privileges for the request a denial of the service
111  *                      will be issued back to the requesting instance.
112  *    - Static Policy - Optionally provided to Client and CD instances at
113  *                      initialization.  Allows these instances to statically 
114  *                      allocate resources.  This feature is typically used
115  *                      for RM instances that must allocate resources prior
116  *                      to the transport connection to the Server being established.
117  *                      Resources allocated via any Static Policies will
118  *                      be validated against the Global Policy once the transport 
119  *                      to the Server has been fully established.  If a Static
120  *                      Policy request fails validation with the Global Policy the
121  *                      RM instance that issued the static request will be placed
122  *                      into a locked state.  The locked state prevents any further
123  *                      service requests from the instance.
124  *
125  *   Combined, the GRL and Policy Device Tree implementations allow RM to easily extend 
126  *   to new resources without the need to recompile the RM source code.
127  *
128  *   RM instances currently provides the following resource services:
129  *    - Allocate (initialize) - Allocate a resource for initialization
130  *    - Allocate (usage)      - Allocate a resource for use
131  *    - Free                  - Free an allocated resource (The free must originate
132  *                              from the RM instance that allocated the resource
133  *    - Map resource to name  - Map a specified resource to a NameServer name
134  *    - Unmap named resource  - Unmap a resource from an existing NameServer name
135  *    - Get resource by name  - Returns a resource based on a provided NameServer name
136  */
137  
138 /* Define RM_API as a master group in Doxygen format and add all RM API 
139    definitions to this group. */
140 /** @defgroup RM_API Resource Manager API
141  *  @{
142  */
143 /** @} */
145 /**
146 @defgroup RM_TRANSPORT_API  RM Transport API
147 @ingroup RM_API
148 */
149 /**
150 @defgroup RM_SERVICES_API  RM Services API
151 @ingroup RM_API
152 */
153 /**
154 @defgroup RM_OSAL_API RM OS Abstraction Layer API
155 @ingroup RM_API
156 */
158 /**
159 @addtogroup RM_API
160 @{
161 */
163 /* RM return and error codes */
164 /** RM successful return code */
165 #define RM_OK                                      0
166 /** RM processing requested service */
167 #define RM_SERVICE_PROCESSING                      1
168 /** RM has approved requested service */
169 #define RM_SERVICE_APPROVED                        2
170 /** RM has approved requested service based on static policy.  Request will be validated 
171  *  against global policy once all transports have been registered */
172 #define RM_SERVICE_APPROVED_STATIC                 3
174 /** RM service request denial reasons base */
175 #define RM_SERVICE_DENIED_BASE                     64
176 /** Request resource not found in policy or allocators */
177 #define RM_SERVICE_DENIED_RES_DOES_NOT_EXIST       RM_SERVICE_DENIED_BASE+1
178 /** Request resource range within not found within resource's allocator */
179 #define RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST RM_SERVICE_DENIED_BASE+2
180 /** Free request resource range not allocated to service's source inst */
181 #define RM_SERVICE_DENIED_RES_NOT_ALLOCD_TO_INST   RM_SERVICE_DENIED_BASE+3
182 /** Free request resource range already free */
183 #define RM_SERVICE_DENIED_RES_ALREADY_FREE         RM_SERVICE_DENIED_BASE+4
184 /** Allocate request resource range partially allocated (Handling of partial allocations
185  *  not yet implemented) */
186 #define RM_SERVICE_DENIED_PARTIAL_ALLOCATION       RM_SERVICE_DENIED_BASE+5
187 /** Free request resource range partially free (Handling of partial frees not yet implemented) */
188 #define RM_SERVICE_DENIED_PARTIAL_FREE             RM_SERVICE_DENIED_BASE+6
189 /** Requirements of allocate request could not be satisfied (occurs for UNSPECIFIED base 
190  *  and/or alignment requests */
191 #define RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET   RM_SERVICE_DENIED_BASE+7
192 /** NameServer add request name string already exists in NameServer */
193 #define RM_SERVICE_DENIED_NAME_EXISTS_IN_NS        RM_SERVICE_DENIED_BASE+8
194 /** Service request instance not in policy "valid-instances" list */
195 #define RM_SERVICE_DENIED_INST_NAME_NOT_VALID      RM_SERVICE_DENIED_BASE+9
196 /** Init allocate request resource range not given init privileges in policy */
197 #define RM_SERVICE_DENIED_INIT_PERM_NOT_GIVEN      RM_SERVICE_DENIED_BASE+10
198 /** Use allocate request resource range not given use privileges in policy */
199 #define RM_SERVICE_DENIED_USE_PERM_NOT_GIVEN       RM_SERVICE_DENIED_BASE+11
200 /** Allocate request resource range marked as exclusive in policy has already been allocated */
201 #define RM_SERVICE_DENIED_EXCLUSIVE_RES_ALLOCD     RM_SERVICE_DENIED_BASE+12
202 /** Allocate request resource range allocated to an instance assigned exclusive privileges in policy */
203 #define RM_SERVICE_DENIED_ALLOCD_TO_EXCLUSIVE_INST RM_SERVICE_DENIED_BASE+13
204 /** Static allocate request was not an allocate-use or allocate-init request */
205 #define RM_SERVICE_DENIED_INVALID_STATIC_REQUEST   RM_SERVICE_DENIED_BASE+14
206 /** Static allocate request denied by static policy */
207 #define RM_SERVICE_DENIED_BY_STATIC_POLICY         RM_SERVICE_DENIED_BASE+15
208 /** RM instance locked from further services since a static allocation failed validation against 
209  *  global policy.  RM instance cannot be unlocked.  Please make sure static policy and global policy 
210  *  are in sync */
211 #define RM_SERVICE_DENIED_RM_INSTANCE_LOCKED       RM_SERVICE_DENIED_BASE+16
213 /** Start of libfdt.h error codes */
214 #define RM_ERROR_LIBFDT_START                      (-1)
215 /** End of libfdt.h error codes */
216 #define RM_ERROR_LIBFDT_END                        (-13)
218 /** RM error base */       
219 #define RM_ERROR_BASE                              (-64)
220 /** Instance name provided is NULL or greater than RM_NAME_MAX_CHARS */
221 #define RM_ERROR_INVALID_INST_NAME                 RM_ERROR_BASE-1
222 /** List of "valid-instances" not found in global or static policy */
223 #define RM_ERROR_NO_VALID_INST_IN_POLICY           RM_ERROR_BASE-2
224 /** Instance specified in permissions string does not match any instances specified in the
225  *  "valid-instances" list */
226 #define RM_ERROR_PERM_STR_INST_NOT_VALID           RM_ERROR_BASE-3
227 /** Resource specified in global policy does not have an allocator */
228 #define RM_ERROR_UNKNOWN_RESOURCE_IN_POLICY        RM_ERROR_BASE-4
229 /** Permissions string has more than instance group specified.
230  *  Ex: assignments = <12 1>, "iux = (RM_Client_Delegate) iu = (RM_Client)"; */
231 #define RM_ERROR_PERM_STR_TOO_MANY_INST_GROUPS     RM_ERROR_BASE-5
232 /** Permissions string has more than assignment.
233  *  Ex: assignments = <12 1>, "iux = (RM_Client_Delegate) = i"; */
234 #define RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS    RM_ERROR_BASE-6
235 /** Permissions string contains invalid character */
236 #define RM_ERROR_PERM_STR_INVALID_CHAR             RM_ERROR_BASE-7
237 /** Permissions string contains a permission character without the assignment operator
238  *  Ex: assignments = <12 1>, "iux (RM_Client_Delegate)"; */
239 #define RM_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR     RM_ERROR_BASE-8
240 /** Permissions string contains a permission character on opposite side of already made assignment
241  *  Ex: assignments = <12 1>, "iux = (RM_Client_Delegate) x"; */
242 #define RM_ERROR_INVALID_PERMS_CHAR_ON_RIGHT       RM_ERROR_BASE-9
243 /** Policy resource node contains an unknown property */
244 #define RM_ERROR_UNKNOWN_POLICY_RESOURCE_PROPERTY  RM_ERROR_BASE-10
245 /** Instance name provided in "valid-instances" list is greater than RM_NAME_MAX_CHARS */
246 #define RM_ERROR_VALID_INST_NAME_TOO_LONG          RM_ERROR_BASE-11
247 /** Instance name in permissions assignment is greater than RM_NAME_MAX_CHARS */
248 #define RM_ERROR_INST_NAME_IN_ASSIGNMENT_TOO_LONG  RM_ERROR_BASE-12
249 /** NameServer name in global resource list nameServer assignment is greater than RM_NAME_MAX_CHARS */
250 #define RM_ERROR_GRL_NS_ASSIGNMENT_NAME_TOO_LONG   RM_ERROR_BASE-13
251 /** Linux alias assignment in global resource list is invalid */
252 #define RM_ERROR_GRL_INVALID_LINUX_ALIAS_FORMAT    RM_ERROR_BASE-14
253 /** Error allocating memory for the service handle */
254 #define RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED   RM_ERROR_BASE-15
255 /** The RM instance service handle has already been opened */
256 #define RM_ERROR_SERVICE_HANDLE_ALREADY_OPENED     RM_ERROR_BASE-16
257 /** The RM instance service handle has already been closed */
258 #define RM_ERROR_SERVICE_HANDLE_ALREADY_CLOSED     RM_ERROR_BASE-17
259 /** Global Resource List (GRL) resource node contains an unknown property */
260 #define RM_ERROR_GRL_UNKNOWN_RESOURCE_PROPERTY     RM_ERROR_BASE-18
261 /** Could not find an allocator for the specified resource */
262 #define RM_ERROR_RES_ALLOCATOR_DOES_NOT_EXIST      RM_ERROR_BASE-19
263 /** A resource node is specified more than once in the Global Resource List (GRL) */
264 #define RM_ERROR_GRL_RES_SPECIFIED_MORE_THAN_ONCE  RM_ERROR_BASE-20
265 /** No data was found at the GRL resource node's specified Linux alias path */
266 #define RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS     RM_ERROR_BASE-21
267 /** RM server was not provided a Global Resource List (GRL) and global policy at initialization */
268 #define RM_ERROR_INVALID_SERVER_CONFIGURATION      RM_ERROR_BASE-22
269 /** Service request type not recognized */
270 #define RM_ERROR_INVALID_SERVICE_TYPE              RM_ERROR_BASE-23
271 /** Service request did not contain callback function.  Callback function must always be provided
272  *  with service request since blocking or non-blocking operations cannot be promised. */
273 #define RM_ERROR_CALLBACK_NOT_PROVIDED             RM_ERROR_BASE-24
274 /** rmAllocPkt transport callout returned NULL for rmPkt */
275 #define RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR         RM_ERROR_BASE-25
276 /** rmSendPkt transport callout returned error when attempting to send the rmPkt */
277 #define RM_ERROR_TRANSPORT_SEND_ERROR              RM_ERROR_BASE-26
278 /** A RM service transaction could not be created for the service request */
279 #define RM_ERROR_SERVICE_TRANS_NOT_CREATED         RM_ERROR_BASE-27
280 /** RM service transaction could not be found in instance's transaction queue */
281 #define RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST      RM_ERROR_BASE-28
282 /** NameServer does not exist in instance, cannot satisfy NameServer service request */
283 #define RM_ERROR_NAMESERVER_DOES_NOT_EXIST         RM_ERROR_BASE-29
284 /** Service request to add a name to the NameServer failed */
285 #define RM_ERROR_NAMESERVER_NAME_ADD_FAILED        RM_ERROR_BASE-30
286 /** Could not find name specified in service request in NameServer */
287 #define RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST    RM_ERROR_BASE-31
288 /** Service request made on Client or CD when no transport established and no static policy registered */
289 #define RM_ERROR_REQ_FAILED_NO_STATIC_POLICY       RM_ERROR_BASE-32
290 /** RM transport handle has not been registered with the RM instance */
291 #define RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST   RM_ERROR_BASE-33
292 /** RM received a packet with an unknown RM packet type */
293 #define RM_ERROR_RECEIVED_INVALID_PACKET_TYPE      RM_ERROR_BASE-34
294 /** RM response packet does not match any requests sent from instance */
295 #define RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ   RM_ERROR_BASE-35
296 /** Server attempted to connect to another server or a CD attempted to connect to another CD or
297  *  Client attempted to connect to another client */
298 #define RM_ERROR_INVALID_REMOTE_INST_TYPE          RM_ERROR_BASE-36
299 /** RM client attempted to register with more than one Server or CD or a CD attempted to register 
300  *  with more than one Server */
301 #define RM_ERROR_ALREADY_REGD_SERVER_OR_CD         RM_ERROR_BASE-37
302 /** Transport registration callout function pointers specified as valid but were NULL */
303 #define RM_ERROR_NULL_CALLOUTS_WHEN_VALID          RM_ERROR_BASE-38
304 /** Service both a NameServer name and a base, length, or alignment */
305 #define RM_ERROR_NS_NAME_AND_RES_VAL_CONFLICT      RM_ERROR_BASE-39
306 /** Instance type not recognized */
307 #define RM_ERROR_INVALID_INST_TYPE                 RM_ERROR_BASE-40
308 /** Linux DTB alias properties specified in GRL but no Linux DTB provided during server instance init */
309 #define RM_ERROR_GRL_LINUX_ALIAS_BUT_NO_DTB        RM_ERROR_BASE-41
310 /** RM attempted to allocate a transport packet but the rmAllocPkt callout was not registered */
311 #define RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD      RM_ERROR_BASE-42
312 /** RM attempted to send a packet but the rmSendPkt callout was not registered */
313 #define RM_ERROR_TRANSPORT_SEND_NOT_REGD           RM_ERROR_BASE-43
315 /** 
316  * @brief Maximum number of characters allowed for RM instance, resource, and
317  *        NameServer names.
318  */
319 #define RM_NAME_MAX_CHARS (32)
321 /** 
322  * @brief RM instance handle.  The RM handle is used to register transports
323  *        between RM instances and request resource services from the RM
324  *        instance.
325  */
326 typedef void *Rm_Handle;
328 /** 
329  * @brief RM instance types
330  */
331 typedef enum {
332     /** RM Server */
333     Rm_instType_SERVER = 0,
334     /** RM Client Delegate */
335     Rm_instType_CLIENT_DELEGATE,
336     /** RM Client */
337     Rm_instType_CLIENT,
338     /** DO NOT USE: Last type */
339     Rm_instType_LAST
340 } Rm_InstType;
342 /**
343  * @brief RM server initialization configurations
344  */
345 typedef struct {
346     /** Pointer to the device global resource list (GRL).  The GRL contains 
347      *  all resources on the device that will be managed by RM.  The GRL
348      *  must be in DTB format. */
349     void *globalResourceList;
350     /** Pointer to the Linux DTB if the RM server is running on ARM Linux.
351      *  The Linux DTB will be parsed for all managed resources reserved for use
352      *  by Linux.  Parsing will be based on "linux-dtb-alias" resource
353      *  properties found in the GRL.  The Linux DTB must be in DTB format.  */
354     void *linuxDtb;    
355     /** Pointer to the global policy defining the allocation policies for
356      *  RM instances within the system.  The global policy must be in DTB
357      *  format. */
358     void *globalPolicy;    
359 } Rm_ServerCfg;
361 /**
362  * @brief RM client delegate (CD) initialization configurations
363  */
364 typedef struct {
365     /** Pointer to a static policy used by the CD to allocate resources statically.
366      *  Static allocations can occur before the instance has been attached to a server
367      *  instance within the RM system.  This is useful for allocating resources
368      *  prior to main().  Resources allocated via the static policy will be verified
369      *  against the global policy once the CD connects with the server.  The static
370      *  policy must be in DTB format. */
371     void *staticPolicy;
372 } Rm_ClientDelegateCfg;
374 /**
375  * @brief RM client initialization configurations
376  */
377 typedef struct {
378     /** Pointer to a static policy used by the client to allocate resources statically.
379      *  Static allocations can occur before the instance has been attached to a server
380      *  or CD instance within the RM system.  This is useful for allocating resources
381      *  prior to main().  Resources allocated via the static policy will be verified
382      *  against the global policy once the client connects with the server (directly or
383      *  indirectly through a CD).  The static policy must be in DTB format. */
384     void *staticPolicy;
385 } Rm_ClientCfg;
387 /** 
388  * @brief RM instance initialization structure
389  */
390 typedef struct {
391     /** Pointer to a character array containing the instance name.  The name of the 
392      *  RM instance can be no greater than #RM_NAME_MAX_CHARS.  The instance name
393      *  must match an instance name defined in the "valid-instances" lists contained
394      *  in the global and static policy DTS files.  Resources and privileges to the
395      *  resources will be based on the name assigned to the RM instance*/
396     char *instName;
397     /** The type of RM instance that will be created. */
398     Rm_InstType instType;
399     /** Instance-type specific configurations */
400     union {
401         /** #Rm_ServerCfg */
402         Rm_ServerCfg serverCfg;
403         /** #Rm_ClientDelegateCfg */
404         Rm_ClientDelegateCfg cdCfg;
405         /** #Rm_ClientCfg */
406         Rm_ClientCfg clientCfg;
407     } instCfg;
408 } Rm_InitCfg;
410 /**
411  *  @b Description
412  *  @n  
413  *      This function prints the status for all resources managed by the
414  *      RM instance network.  The allocate/free status as well as ownership
415  *      status will be printed for every resource.  Also, the NameServer name
416  *      entries will be displayed.
417  *
418  *      This function only prints resources when provided the server handle
419  *      since the server stores all the resource and NameServer
420  *      data structures.
421  *
422  *  @param[in]  rmServerHandle
423  *      Server instance handle.
424  */
425 void Rm_printResourceStatus(Rm_Handle rmServerHandle);
427 /**
428  *  @b Description
429  *  @n  
430  *      This function prints the current status of a RM instance.  The
431  *      following instance properties will be printed:
432  *      a) instance name & type
433  *      b) The instance's registered transports 
434  *      c) All service transactions queued in the instance transaction
435  *         queue and their states
436  *
437  *  @param[in]  rmHandle
438  *      Instance handle.
439  */
440 void Rm_printInstanceStatus(Rm_Handle rmHandle);
442 /**
443  *  @b Description
444  *  @n  
445  *      This function initializes a RM instance.  There are no restrictions
446  *      on the amount of times this function can be called.  Each call will
447  *      result in a new RM instance.  However, a network of RM instances
448  *      can have only one RM Server.  If an application has multiple RM
449  *      Servers the resources managed by each server must be mutually
450  *      exclusive.
451  *
452  *      If any errors are encountered during the initialization process
453  *      the Rm_Handle returned will be NULL.
454  *
455  *  @param[in]  initCfg
456  *      Pointer to the instance initialization structure.
457  *
458  *  @param[out] result
459  *      Pointer to a signed int used to return any errors encountered during
460  *      the instance initialization process.
461  *
462  *  @retval
463  *      Success - Rm_Handle for instance and result = #RM_OK
464  *  @retval
465  *      Failure - NULL Rm_Handle and result < #RM_OK
466  */
467 Rm_Handle Rm_init(Rm_InitCfg *initCfg, int32_t *result);
469 /**
470  *  @b Description
471  *  @n  
472  *      The function is used to get the version information of RM.
473  *
474  *  @retval
475  *      Version Information.
476  */
477 uint32_t Rm_getVersion (void);
479 /**
480  *  @b Description
481  *  @n  
482  *      The function is used to get the version string for RM.
483  *
484  *  @retval
485  *      Version String.
486  */
487 const char* Rm_getVersionStr (void);
489 /** 
490 @} 
491 */
493 #ifdef __cplusplus
495 #endif
497 #endif /* RM_H_ */