ec96813dae3eaeb047dc14703b552438cb01e181
[keystone-rtos/rm-lld.git] / test / rm_test.c
1 /* 
2  * Copyright (c) 2012, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  * */
32 /*
33  *  ======== rm_test.c ========
34  *  RM multicore test example
35  *
36  *  This is an example program that uses MessageQ to pass a message
37  *  from one processor to another.
38  *
39  *  Each processor creates its own MessageQ first and then will try to open
40  *  a remote processor's MessageQ.  
41  *
42  *  See message_multicore.k file for expected output.
43  */
45 #include <c6x.h>
46 #include <xdc/std.h>
47 #include <string.h>
48 #include <stdbool.h>
50 /*  -----------------------------------XDC.RUNTIME module Headers    */
51 #include <xdc/runtime/System.h>
52 #include <xdc/runtime/IHeap.h>
54 /*  ----------------------------------- IPC module Headers           */
55 #include <ti/ipc/Ipc.h>
56 #include <ti/ipc/MessageQ.h>
57 #include <ti/ipc/HeapBufMP.h>
58 #include <ti/ipc/MultiProc.h>
60 /*  ----------------------------------- BIOS6 module Headers         */
61 #include <ti/sysbios/BIOS.h>
62 #include <ti/sysbios/knl/Task.h>
64 /*  ----------------------------------- Resource Manager Headers         */
65 #include <ti/drv/rm/rm.h>
66 #include <ti/drv/rm/rm_transport.h>
67 #include <ti/drv/rm/rm_services.h>
69 /* ======== Task Handles ======== */
70 Task_Handle startupRmTskHandle;
72 /* ======== Application Heaps ======== */
73 #define RM_PKT_HEAP_NAME   "rmHeapBuf"
74 HeapBufMP_Handle rmPktHeapHandle = NULL;
76 #define MSGQ_HEAP_NAME   "msgQHeapBuf"
77 #define MSGQ_HEAP_ID      0
79 /* ======== RM Instance Names ======== */
80 Char rmServerName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Server";
81 Char rmClientDelegateName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client_Delegate";
82 Char rmClientName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client";
84 /* ======== RM IPC MessageQ Names ======== */
85 Char serverCdQueueName[30] = "RM_Server_CD_Queue";
86 Char cdServerQueueName[30] = "RM_CD_Server_Queue";
87 Char cdClientQueueName[30] = "RM_CD_Client_Queue";
88 Char clientCdQueueName[30] = "RM_Client_CD_Queue";
90 /* ======== RM Instance Handles ======== */
91 Rm_Handle rmServerHandle = NULL;
92 Rm_Handle rmClientDelegateHandle = NULL;
93 Rm_Handle rmClientHandle = NULL;
95 /* ======== RM Transport Packet Definition ======== */
96 typedef struct {
97   MessageQ_MsgHeader msgQHeader;
98   /* Pointer to packet provided by RM */
99   Rm_Packet *rmPkt;
100 } MsgQ_RmPacket;
102 /* ======== RM Transport Mapping Tables for Application ======== */
103 /* Core 0 Map Entry Indices */
104 #define SERVER_TO_CD_MAP_ENTRY 0
105 /* Core 1 Map Entry Indicies */
106 #define CD_TO_SERVER_MAP_ENTRY 0
107 #define CD_TO_CLIENT_MAP_ENTRY 1
108 #define CLIENT_TO_CD_MAP_ENTRY 2
110 /* Max map entries across all cores */
111 #define MAX_MAPPING_ENTRIES 3
113 typedef struct {
114     Rm_TransportHandle transportHandle;
115     MessageQ_Handle receiveMsgQ;
116     MessageQ_QueueId remoteMsgQId;
117 } Transport_MapEntry;
119 /* Core 1 will have three mapping entries
120  * Two map entries for the Client Delegate
121  * One map entry for the Client */
122 Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
124 /* ======== RM Application Transport APIs ======== */
126 Rm_Packet *TransportAlloc (Rm_TransportHandle transportHandle, uint32_t pktSize)
128     Rm_Packet *pkt = NULL;
130     /* All transports will allocate from the same heap */
131     
132     HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
134     if (pkt != NULL)
135     {
136        pkt->pktLenBytes = pktSize;
137     }
139     return (pkt);
142 int32_t TransportFree (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
144     uint32_t pktSize = pkt->pktLenBytes;
146     /* All transports will free to the same heap */
147     
148     HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
150     return (0);    
153 int32_t TransportSend (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
155     MsgQ_RmPacket *rmMsg = NULL;
156     MessageQ_QueueId remoteQueueId;
157     bool handleValid = false;
158     int32_t status, i;    
160     /* Get the remoteQueueId based on the transportHandle */
161     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
162     {
163         /* transportHandle found in mapping table.  Get the remoteQueueId associated
164          * with it */
165         if (rmTransportMap[i].transportHandle == transportHandle)
166         {
167             remoteQueueId = rmTransportMap[i].remoteMsgQId;
168             /* Break out of the search loop */
169             handleValid = true;
170             break;
171         }
172     }
174     if (handleValid)
175     {
176         /* Allocate a messageQ message for containing the RM packet */
177         rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
178         if (rmMsg == NULL) 
179         {
180             System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
181         }
183         /* Attach the RM packet to the MessageQ message */
184         rmMsg->rmPkt = pkt;
185         /* Send the message to the remote side */
186         status = MessageQ_put(remoteQueueId, rmMsg);
187         if (status < 0) 
188         { 
189             System_printf("Core %d: MessageQ_put had a failure/error in TransportSend\n", MultiProc_self());
190         }
191     }
192     else
193     {   
194         /* Could not find a registered transport handle that matched the handle provided by RM.
195          * Return an error to RM. */
196         System_printf("Core %d: TransportSend couldn't find transportHandle in transport map\n", MultiProc_self());
197         status = -1;
198     }
199     
200     return (status);
203 void * TransportReceive (Rm_TransportHandle transportHandle)
205     MessageQ_Handle receiveQ;
206     MessageQ_Msg rmMsg = NULL;
207     Rm_Packet *rmPkt = NULL;
208     bool queueValid = false;
209     int32_t status, i;    
211     /* Get the receiveQ based on the transportHandle */
212     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
213     {
214         /* transportHandle found in mapping table.  Get the receiveQ associated
215          * with it */
216         if (rmTransportMap[i].transportHandle == transportHandle)
217         {
218             receiveQ = rmTransportMap[i].receiveMsgQ;
219             /* Break out of the search loop */
220             queueValid = true;
221             break;
222         }
223     }
225     if (queueValid)
226     {
227         /* Get the next message from the receiveQ */
228         status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
229         if (status < 0) 
230         {
231             System_abort("This should not happen since timeout is forever\n");
232         }
233         if (rmMsg == NULL) 
234         {
235             System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
236         }
238         /* Extract the Rm_Packet from the RM msg */
239         rmPkt = ((MsgQ_RmPacket)rmMsg).rmPkt;
241         /* Free the messageQ message now that RM packet pointer has been extracted */
242         status = MessageQ_free(rmMsg);
243         if (status < 0) 
244         { 
245             System_printf("Core %d: MessageQ_free had a failure/error in TransportReceive\n", MultiProc_self());
246         }
247     }
248     else
249     {   
250         /* Could not find a registered transport handle that matched the handle provided by RM.
251          * Return an error to RM. */
252         System_printf("Core %d: TransportReceive couldn't find transportHandle in transport map\n", MultiProc_self());
253     }
255     /* Pass the RM packet back to RM */
256     return ((void *)rmPkt);
259 int32_t TransportNumPktsReceived (Rm_TransportHandle transportHandle)
261     MessageQ_Handle receiveQ;
262     bool queueValid = false;
263     int32_t numPkts, i;    
265     /* Get the receiveQ based on the transportHandle */
266     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
267     {
268         /* transportHandle found in mapping table.  Get the receiveQ associated
269          * with it */
270         if (rmTransportMap[i].transportHandle == transportHandle)
271         {
272             receiveQ = rmTransportMap[i].receiveMsgQ;
273             /* Break out of the search loop */
274             queueValid = true;
275             break;
276         }
277     }
279     if (queueValid)
280     {
281         /* Get the number of messages in the receiveQ */
282         numPkts = (int32_t) MessageQ_count(receiveQ);
283     }
284     else
285     {   
286         /* Could not find a registered transport handle that matched the handle provided by RM.
287          * Return an error to RM. */
288         System_printf("Core %d: TransportNumPktsReceived couldn't find transportHandle in transport map\n", MultiProc_self());
289         numPkts = -1;
290     }
291     
292     return (numPkts);
295 /*
296  *  ======== testRmTsk ========
297  *  RM test task
298  */
299 Void testRmTsk(UArg arg0, UArg arg1)
301     /* Delete the RM startup task */
302     System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
303     if (startupRmTskHandle)
304     {
305         Task_delete(startupRmTskHandle);
306         /* Set the task handle to be NULL so that the delete only occurs once */
307         startupRmTskHandle = NULL;
308     }
310     /* Start running Tests */
312     System_printf("The test is complete\n");
313     BIOS_exit(0);
316 /*
317  *  ======== startupRmTsk ========
318  *  Configures application transports and registers them with RM
319  */
320 Void startupRmTsk(UArg arg0, UArg arg1)
322     MessageQ_Msg     msg;    
323     MessageQ_Handle  serverCdMsgQ, cdServerMsgQ, cdClientMsgQ, clientCdMsgQ;
324     MessageQ_QueueId serverCdQId, cdServerQId, cdClientQId, clientCdQId;    
325     Int              status, i;
326     HeapBufMP_Handle msgQHeapHandle;
327     HeapBufMP_Params heapBufParams;
328     Rm_TransportCfg rmTransportCfg;
329     Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
330     Task_Params taskParams;
331         Task_Handle taskHandle;
333     /* Initialize the transport map */
334     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
335     {
336         rmTransportMap[i].transportHandle = NULL;
337     }
339     if (MultiProc_self() == 0)
340     {
341         /* Create the heap that will be used to allocate RM messages. This
342          * heap is a multi-processor heap.  It will be shared amongst
343          * all RM instances. */     
344         HeapBufMP_Params_init(&heapBufParams);
345         heapBufParams.regionId       = 0;
346         heapBufParams.name           = RM_PKT_HEAP_NAME;
347         heapBufParams.numBlocks      = 64;
348         heapBufParams.blockSize      = sizeof(Rm_Packet);
349         rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
350         if (rmPktHeapHandle == NULL) 
351         {
352             System_abort("HeapBufMP_create failed for RM packet heap\n" );
353         }
354         System_printf("Core %d: RM packet heap created\n", MultiProc_self());
356         /* Create the heap that will be used to allocate messageQ messages. */     
357         HeapBufMP_Params_init(&heapBufParams);
358         heapBufParams.regionId       = 0;
359         heapBufParams.name           = MSGQ_HEAP_NAME;
360         heapBufParams.numBlocks      = 64;
361         heapBufParams.blockSize      = sizeof(MsgQ_RmPacket);
362         msgQHeapHandle = HeapBufMP_create(&heapBufParams);
363         if (msgQHeapHandle == NULL) 
364         {
365             System_abort("HeapBufMP_create failed MessageQ message heap\n" );
366         } 
367         System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
368     }
369     else 
370     {
371         /* Open the heaps created by the other processor. Loop until opened. */
372         do 
373         {
374             status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
375             /* 
376              *  Sleep for 1 clock tick to avoid inundating remote processor
377              *  with interrupts if open failed
378              */
379             if (status < 0)
380             { 
381                 Task_sleep(1);
382             }
383         } while (status < 0);
384         System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
385         
386         do 
387         {
388             status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
389             /* 
390              *  Sleep for 1 clock tick to avoid inundating remote processor
391              *  with interrupts if open failed
392              */
393             if (status < 0)
394             { 
395                 Task_sleep(1);
396             }
397         } while (status < 0);
398         System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
399     }
400     
401     /* Register the MessageQ heap with MessageQ */
402     MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
404     /* Create the messageQ's for each RM instance connection
405      * Need four queues.  Topology will be:
406      * RM Server <---> RM Client Delegate <---> RM Client 
407      * 1 queue on RM Server
408      * 2 queues on RM Client Delegate
409      * 1 queue on RM Client */
410     if (MultiProc_self() == 0)
411     {
412         /* Create the RM Server messageQ used by the RM Client Delegate */
413         serverCdMsgQ = MessageQ_create(serverCdQueueName, NULL);
414         if (serverCdMsgQ == NULL) 
415         {
416             System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
417         }
418         System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
419     }
420     else if (MultiProc_self() == 1)
421     {
422         /* Create the RM Client Delegate messageQ used by the RM Server */
423         cdServerMsgQ = MessageQ_create(cdServerQueueName, NULL);
424         if (cdServerMsgQ == NULL) 
425         {
426             System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
427         }
428         System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
429         /* Create the RM Client Delegate messageQ used by the RM Client */
430         cdClientMsgQ = MessageQ_create(cdClientQueueName, NULL);
431         if (cdClientMsgQ == NULL) 
432         {
433             System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
434         } 
435         System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
436         /* Create the RM Client messageQ used by the RM Client Delegate */
437         clientCdMsgQ = MessageQ_create(clientCdQueueName, NULL;
438         if (clientCdMsgQ == NULL) 
439         {
440             System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
441         }
442         System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self());
443     }
444     
445     /* Open the remote message queues. Also register the RM transports with each RM instance */
446     if (MultiProc_self() == 0)
447     {
448         /* Open the Client Delegate messageQ from the Server */
449         do 
450         {
451             status = MessageQ_open(cdServerQueueName, &serverCdQId); 
452             /* 
453              *  Sleep for 1 clock tick to avoid inundating remote processor
454              *  with interrupts if open failed
455              */
456             if (status < 0)
457             { 
458                 Task_sleep(1);
459             }
460         } while (status < 0);
461         System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
463         /* Register the Client Delegate with the RM Server Instance */
464         rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
465         rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
466         rmTransportCfg.transportCalloutsValid = true;
467         rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
468         rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
469         rmTransportCfg.transportCallouts.rmSend = TransportSend;
470         rmTransportCfg.transportCallouts.rmReceive = TransportReceive;        
471         rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived; 
473         serverCdHandle = Rm_transportRegister(rmServerHandle, rmTransportCfg);
475         /* Store the mapping information in the transport map */
476         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
477         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverCdMsgQ;
478         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].remoteMsgQId = serverCdQId;
479         System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
480         
481     }
482     else if (MultiProc_self() == 1)
483     {
484         /* Open the Server messageQ from the Client Delegate */
485         do 
486         {
487             status = MessageQ_open(serverCdQueueName, &cdServerQId); 
488             /* 
489              *  Sleep for 1 clock tick to avoid inundating remote processor
490              *  with interrupts if open failed
491              */
492             if (status < 0) 
493             { 
494                 Task_sleep(1);
495             }
496         } while (status < 0);
497         System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
499         /* Register the Server with the RM Client Delegate Instance */
500         rmTransportCfg.remoteInstType = Rm_instType_SERVER;
501         rmTransportCfg.remoteInstName = &rmServerName[0];
502         /* Set the callouts as valid for the first transport configuration on this core */
503         rmTransportCfg.transportCalloutsValid = true;
504         rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
505         rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
506         rmTransportCfg.transportCallouts.rmSend = TransportSend;
507         rmTransportCfg.transportCallouts.rmReceive = TransportReceive;        
508         rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived; 
510         cdServerHandle = Rm_transportRegister(rmClientDelegateHandle, rmTransportCfg);
512         /* Store the mapping information in the transport map */
513         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
514         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdServerMsgQ;
515         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].remoteMsgQId = cdServerQId;
516         System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
517         
518         /* Open the Client messageQ from the Client Delegate */
519         do 
520         {
521             status = MessageQ_open(clientCdQueueName, &cdClientQId); 
522             /* 
523              *  Sleep for 1 clock tick to avoid inundating remote processor
524              *  with interrupts if open failed
525              */
526             if (status < 0) 
527             { 
528                 Task_sleep(1);
529             }
530         } while (status < 0);
531         System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
533         /* Register the Client with the RM Client Delegate Instance */
534         rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
535         rmTransportCfg.remoteInstName = &rmClientName[0];
536         /* Callouts already set so set them as invalid */
537         rmTransportCfg.transportCalloutsValid = false;
539         cdClientHandle = Rm_transportRegister(rmClientDelegateHandle, rmTransportCfg);
541         /* Store the mapping information in the transport map */
542         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
543         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdClientMsgQ;
544         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].remoteMsgQId = cdClientQId;
545         System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
546         
547         /* Open the Client Delegate messageQ from the Client */        
548         do 
549         {
550             status = MessageQ_open(cdClientQueueName, &clientCdQId); 
551             /* 
552              *  Sleep for 1 clock tick to avoid inundating remote processor
553              *  with interrupts if open failed
554              */
555             if (status < 0) 
556             { 
557                 Task_sleep(1);
558             }
559         } while (status < 0);
560         System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
562         /* Register the Client Delegate with the RM Client Instance */
563         rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
564         rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
565         /* Callouts already set so set them as invalid */
566         rmTransportCfg.transportCalloutsValid = false;
568         clientCdHandle = Rm_transportRegister(rmClientHandle, rmTransportCfg);
570         /* Store the mapping information in the transport map */
571         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
572         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientCdMsgQ;
573         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].remoteMsgQId = clientCdQId; 
574         System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
575     }
576     
577     /* Create the RM test task. */
578     System_printf("Core %d: Creating RM test task...\n", MultiProc_self());
579     Task_Params_init (&taskParams);
580     Task_create (testRmTsk, &taskParams, NULL);
583 /*
584  *  ======== main ========
585  *  Synchronizes all processors (in Ipc_start) and calls BIOS_start
586  */
587 Int main(Int argc, Char* argv[])
589     Rm_InitCfg rmInitCfg;
590     Rm_Handle rmHandle = NULL;
591     Task_Params taskParams;
592     Int status;
594     System_printf ("*********************************************************\n");
595     System_printf ("********************** RM Testing ***********************\n");
596     System_printf ("*********************************************************\n");
598     System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
600     /* Initialize the RM instances - RM must be initialized before anything else in the system
601      * Core 0: 1 RM Instance - RM Server
602      * Core 1: 2 RM Instances - RM Client Delegate
603      *                          RM Client
604      */
605     if (MultiProc_self()== 0)
606     {
607         /* Create the RM Server instance */
608         rmInitCfg.instName = &rmServerName[0];
609         rmInitCfg.instType = Rm_instType_SERVER;
610         /* SET TO NULL - FEATURES NOT ADDED YET */
611         rmInitCfg.globalResourceList = NULL;
612         rmInitCfg.startupPolicy = NULL;
614         /* Get the RM Server handle */
615         rmServerHandle = Rm_init(&rmInitCfg);
616         System_printf("Core %d: RM Server instance created\n", MultiProc_self());
617     }
618     else if (MultiProc_self()== 1)
619     {
620         /* Create the RM Client Delegate instance */
621         rmInitCfg.instName = &rmClientDelegateName[0];
622         rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
623         /* SET TO NULL - FEATURES NOT ADDED YET */
624         rmInitCfg.globalResourceList = NULL;
625         rmInitCfg.startupPolicy = NULL;
627         /* Get the RM Client Delegate handle */
628         rmClientDelegateHandle = Rm_init(&rmInitCfg);
629         System_printf("Core %d: RM Client Delegate instance created\n", MultiProc_self());
631         /* Create the RM Client instance */
632         rmInitCfg.instName = &rmClientName[0];
633         rmInitCfg.instType = Rm_instType_CLIENT;
634         /* SET TO NULL - FEATURES NOT ADDED YET */
635         rmInitCfg.globalResourceList = NULL;
636         rmInitCfg.startupPolicy = NULL;
638         /* Get the RM Client handle */
639         rmClientHandle = Rm_init(&rmInitCfg);
640         System_printf("Core %d: RM Client instance created\n", MultiProc_self());
641     }
643     /*  
644      *  Ipc_start() calls Ipc_attach() to synchronize all remote processors
645      *  because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
646      */
647     System_printf("Core %d: Starting IPC...\n", MultiProc_self());
648     status = Ipc_start();
649     if (status < 0) 
650     {
651         System_abort("Ipc_start failed\n");
652     }
654     /* Create the RM startup task */
655     System_printf("Core %d: Creating RM startup task...\n", MultiProc_self());
656     Task_Params_init (&taskParams);
657     startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL);
659     System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
660     BIOS_start();
662     return (0);