Coded basic test project started removing receipt construct
[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 Instance Service Ports ======== */
96 Rm_ServicePort *rmServerServicePort = NULL;
97 Rm_ServicePort *rmClientDelegateServicePort = NULL;
98 Rm_ServicePort *rmClientServicePort = NULL;
100 /* ======== RM Transport Packet Definition ======== */
101 typedef struct {
102   MessageQ_MsgHeader msgQHeader;
103   /* Pointer to packet provided by RM */
104   Rm_Packet *rmPkt;
105 } MsgQ_RmPacket;
107 /* ======== RM Transport Mapping Tables for Application ======== */
108 /* Core 0 Map Entry Indices */
109 #define SERVER_TO_CD_MAP_ENTRY 0
110 /* Core 1 Map Entry Indicies */
111 #define CD_TO_SERVER_MAP_ENTRY 0
112 #define CD_TO_CLIENT_MAP_ENTRY 1
113 #define CLIENT_TO_CD_MAP_ENTRY 2
115 /* Max map entries across all cores */
116 #define MAX_MAPPING_ENTRIES 3
118 typedef struct {
119     Rm_TransportHandle transportHandle;
120     MessageQ_Handle receiveMsgQ;
121     MessageQ_QueueId remoteMsgQId;
122 } Transport_MapEntry;
124 /* Core 1 will have three mapping entries
125  * Two map entries for the Client Delegate
126  * One map entry for the Client */
127 Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
129 /* ======== RM Application Transport APIs ======== */
131 Rm_Packet *TransportAlloc (Rm_TransportHandle transportHandle, uint32_t pktSize)
133     Rm_Packet *pkt = NULL;
135     /* All transports will allocate from the same heap */
136     
137     HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
139     if (pkt != NULL)
140     {
141        pkt->pktLenBytes = pktSize;
142     }
144     return (pkt);
147 int32_t TransportFree (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
149     uint32_t pktSize = pkt->pktLenBytes;
151     /* All transports will free to the same heap */
152     
153     HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
155     return (0);    
158 int32_t TransportSend (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
160     MsgQ_RmPacket *rmMsg = NULL;
161     MessageQ_QueueId remoteQueueId;
162     bool handleValid = false;
163     int32_t status, i;    
165     /* Get the remoteQueueId based on the transportHandle */
166     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
167     {
168         /* transportHandle found in mapping table.  Get the remoteQueueId associated
169          * with it */
170         if (rmTransportMap[i].transportHandle == transportHandle)
171         {
172             remoteQueueId = rmTransportMap[i].remoteMsgQId;
173             /* Break out of the search loop */
174             handleValid = true;
175             break;
176         }
177     }
179     if (handleValid)
180     {
181         /* Allocate a messageQ message for containing the RM packet */
182         rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
183         if (rmMsg == NULL) 
184         {
185             System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
186         }
188         /* Attach the RM packet to the MessageQ message */
189         rmMsg->rmPkt = pkt;
190         /* Send the message to the remote side */
191         status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
192         if (status < 0) 
193         { 
194             System_printf("Core %d: MessageQ_put had a failure/error in TransportSend\n", MultiProc_self());
195         }
196     }
197     else
198     {   
199         /* Could not find a registered transport handle that matched the handle provided by RM.
200          * Return an error to RM. */
201         System_printf("Core %d: TransportSend couldn't find transportHandle in transport map\n", MultiProc_self());
202         status = -1;
203     }
204     
205     return (status);
208 void * TransportReceive (Rm_TransportHandle transportHandle)
210     MessageQ_Handle receiveQ;
211     MessageQ_Msg rmMsg = NULL;
212     Rm_Packet *rmPkt = NULL;
213     bool queueValid = false;
214     int32_t status, i;    
216     /* Get the receiveQ based on the transportHandle */
217     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
218     {
219         /* transportHandle found in mapping table.  Get the receiveQ associated
220          * with it */
221         if (rmTransportMap[i].transportHandle == transportHandle)
222         {
223             receiveQ = rmTransportMap[i].receiveMsgQ;
224             /* Break out of the search loop */
225             queueValid = true;
226             break;
227         }
228     }
230     if (queueValid)
231     {
232         /* Get the next message from the receiveQ */
233         status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
234         if (status < 0) 
235         {
236             System_abort("This should not happen since timeout is forever\n");
237         }
238         if (rmMsg == NULL) 
239         {
240             System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
241         }
243         /* Extract the Rm_Packet from the RM msg */
244         rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
246         /* Free the messageQ message now that RM packet pointer has been extracted */
247         status = MessageQ_free(rmMsg);
248         if (status < 0) 
249         { 
250             System_printf("Core %d: MessageQ_free had a failure/error in TransportReceive\n", MultiProc_self());
251         }
252     }
253     else
254     {   
255         /* Could not find a registered transport handle that matched the handle provided by RM.
256          * Return an error to RM. */
257         System_printf("Core %d: TransportReceive couldn't find transportHandle in transport map\n", MultiProc_self());
258     }
260     /* Pass the RM packet back to RM */
261     return ((void *)rmPkt);
264 int32_t TransportNumPktsReceived (Rm_TransportHandle transportHandle)
266     MessageQ_Handle receiveQ;
267     bool queueValid = false;
268     int32_t numPkts, i;    
270     /* Get the receiveQ based on the transportHandle */
271     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
272     {
273         /* transportHandle found in mapping table.  Get the receiveQ associated
274          * with it */
275         if (rmTransportMap[i].transportHandle == transportHandle)
276         {
277             receiveQ = rmTransportMap[i].receiveMsgQ;
278             /* Break out of the search loop */
279             queueValid = true;
280             break;
281         }
282     }
284     if (queueValid)
285     {
286         /* Get the number of messages in the receiveQ */
287         numPkts = (int32_t) MessageQ_count(receiveQ);
288     }
289     else
290     {   
291         /* Could not find a registered transport handle that matched the handle provided by RM.
292          * Return an error to RM. */
293         System_printf("Core %d: TransportNumPktsReceived couldn't find transportHandle in transport map\n", MultiProc_self());
294         numPkts = -1;
295     }
296     
297     return (numPkts);
300 /*
301  *  ======== testServiceCallback ========
302  *  Application's callback function given to RM on service requests
303  */
304 Void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
309 /*
310  *  ======== testRmTsk ========
311  *  RM test task
312  */
313 Void testRmTsk(UArg arg0, UArg arg1)
315     Rm_ServiceReqInfo requestInfo;
316     Rm_ServiceRespInfo responseInfo;
317        
318     /* Delete the RM startup task */
319     System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
320     if (startupRmTskHandle)
321     {
322         Task_delete(&startupRmTskHandle);
323         /* Set the task handle to be NULL so that the delete only occurs once */
324         startupRmTskHandle = NULL;
325     }
327     /* Open service ports on all the RM instances to test service requests from the different
328      * RM instances */
329     if (MultiProc_self() == 0)
330     {
331         rmServerServicePort = Rm_getServicePort(rmServerHandle);
332     }
333     else if (MultiProc_self() == 1)
334     {
335         rmClientDelegateServicePort = Rm_getServicePort(rmClientDelegateHandle);
336         rmClientServicePort = Rm_getServicePort(rmClientHandle);
337     }
339     memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
340     memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
342     /* Use the service ports to test the service requests */
343     if (MultiProc_self() == 0)
344     {
345         char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "hw_semaphore";
346         char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "dsp_core_lock";
347                 
348         /* TEMP: Try mapping a resource in Name Server */
349         requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
350         requestInfo.resourceName = &resourceName[0];
351         requestInfo.resourceBase = 0;
352         requestInfo.resourceRange = 1;
353         requestInfo.resourceNsName = &resourceNsName[0];
354         requestInfo.callback.serviceCallback = testServiceCallback;
355         
356         /* Issue the service request via the service port */
357         rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
358     }
359     else if (MultiProc_self() == 1)
360     {
362     }
364     System_printf("The test is complete\n");
365     BIOS_exit(0);
368 /*
369  *  ======== startupRmTsk ========
370  *  Configures application transports and registers them with RM
371  */
372 Void startupRmTsk(UArg arg0, UArg arg1)
374     MessageQ_Handle  serverCdMsgQ, cdServerMsgQ, cdClientMsgQ, clientCdMsgQ;
375     MessageQ_QueueId serverCdQId, cdServerQId, cdClientQId, clientCdQId;    
376     Int              status, i;
377     HeapBufMP_Handle msgQHeapHandle;
378     HeapBufMP_Params heapBufParams;
379     Rm_TransportCfg rmTransportCfg;
380     Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
381     Task_Params taskParams;
383     /* Initialize the transport map */
384     for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
385     {
386         rmTransportMap[i].transportHandle = NULL;
387     }
389     if (MultiProc_self() == 0)
390     {
391         /* Create the heap that will be used to allocate RM messages. This
392          * heap is a multi-processor heap.  It will be shared amongst
393          * all RM instances. */     
394         HeapBufMP_Params_init(&heapBufParams);
395         heapBufParams.regionId       = 0;
396         heapBufParams.name           = RM_PKT_HEAP_NAME;
397         heapBufParams.numBlocks      = 64;
398         heapBufParams.blockSize      = sizeof(Rm_Packet);
399         rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
400         if (rmPktHeapHandle == NULL) 
401         {
402             System_abort("HeapBufMP_create failed for RM packet heap\n" );
403         }
404         System_printf("Core %d: RM packet heap created\n", MultiProc_self());
406         /* Create the heap that will be used to allocate messageQ messages. */     
407         HeapBufMP_Params_init(&heapBufParams);
408         heapBufParams.regionId       = 0;
409         heapBufParams.name           = MSGQ_HEAP_NAME;
410         heapBufParams.numBlocks      = 64;
411         heapBufParams.blockSize      = sizeof(MsgQ_RmPacket);
412         msgQHeapHandle = HeapBufMP_create(&heapBufParams);
413         if (msgQHeapHandle == NULL) 
414         {
415             System_abort("HeapBufMP_create failed MessageQ message heap\n" );
416         } 
417         System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
418     }
419     else 
420     {
421         /* Open the heaps created by the other processor. Loop until opened. */
422         do 
423         {
424             status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
425             /* 
426              *  Sleep for 1 clock tick to avoid inundating remote processor
427              *  with interrupts if open failed
428              */
429             if (status < 0)
430             { 
431                 Task_sleep(1);
432             }
433         } while (status < 0);
434         System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
435         
436         do 
437         {
438             status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
439             /* 
440              *  Sleep for 1 clock tick to avoid inundating remote processor
441              *  with interrupts if open failed
442              */
443             if (status < 0)
444             { 
445                 Task_sleep(1);
446             }
447         } while (status < 0);
448         System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
449     }
450     
451     /* Register the MessageQ heap with MessageQ */
452     MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
454     /* Create the messageQ's for each RM instance connection
455      * Need four queues.  Topology will be:
456      * RM Server <---> RM Client Delegate <---> RM Client 
457      * 1 queue on RM Server
458      * 2 queues on RM Client Delegate
459      * 1 queue on RM Client */
460     if (MultiProc_self() == 0)
461     {
462         /* Create the RM Server messageQ used by the RM Client Delegate */
463         serverCdMsgQ = MessageQ_create(serverCdQueueName, NULL);
464         if (serverCdMsgQ == NULL) 
465         {
466             System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
467         }
468         System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
469     }
470     else if (MultiProc_self() == 1)
471     {
472         /* Create the RM Client Delegate messageQ used by the RM Server */
473         cdServerMsgQ = MessageQ_create(cdServerQueueName, NULL);
474         if (cdServerMsgQ == NULL) 
475         {
476             System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
477         }
478         System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
479         /* Create the RM Client Delegate messageQ used by the RM Client */
480         cdClientMsgQ = MessageQ_create(cdClientQueueName, NULL);
481         if (cdClientMsgQ == NULL) 
482         {
483             System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
484         } 
485         System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
486         /* Create the RM Client messageQ used by the RM Client Delegate */
487         clientCdMsgQ = MessageQ_create(clientCdQueueName, NULL);
488         if (clientCdMsgQ == NULL) 
489         {
490             System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
491         }
492         System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self());
493     }
494     
495     /* Open the remote message queues. Also register the RM transports with each RM instance */
496     if (MultiProc_self() == 0)
497     {
498         /* Open the Client Delegate messageQ from the Server */
499         do 
500         {
501             status = MessageQ_open(cdServerQueueName, &serverCdQId); 
502             /* 
503              *  Sleep for 1 clock tick to avoid inundating remote processor
504              *  with interrupts if open failed
505              */
506             if (status < 0)
507             { 
508                 Task_sleep(1);
509             }
510         } while (status < 0);
511         System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
513         /* Register the Client Delegate with the RM Server Instance */
514         rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
515         rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
516         rmTransportCfg.transportCalloutsValid = true;
517         rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
518         rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
519         rmTransportCfg.transportCallouts.rmSend = TransportSend;
520         rmTransportCfg.transportCallouts.rmReceive = TransportReceive;        
521         rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived; 
523         serverCdHandle = Rm_transportRegister(rmServerHandle, &rmTransportCfg);
525         /* Store the mapping information in the transport map */
526         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
527         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverCdMsgQ;
528         rmTransportMap[SERVER_TO_CD_MAP_ENTRY].remoteMsgQId = serverCdQId;
529         System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
530         
531     }
532     else if (MultiProc_self() == 1)
533     {
534         /* Open the Server messageQ from the Client Delegate */
535         do 
536         {
537             status = MessageQ_open(serverCdQueueName, &cdServerQId); 
538             /* 
539              *  Sleep for 1 clock tick to avoid inundating remote processor
540              *  with interrupts if open failed
541              */
542             if (status < 0) 
543             { 
544                 Task_sleep(1);
545             }
546         } while (status < 0);
547         System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
549         /* Register the Server with the RM Client Delegate Instance */
550         rmTransportCfg.remoteInstType = Rm_instType_SERVER;
551         rmTransportCfg.remoteInstName = &rmServerName[0];
552         /* Set the callouts as valid for the first transport configuration on this core */
553         rmTransportCfg.transportCalloutsValid = true;
554         rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
555         rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
556         rmTransportCfg.transportCallouts.rmSend = TransportSend;
557         rmTransportCfg.transportCallouts.rmReceive = TransportReceive;        
558         rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived; 
560         cdServerHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
562         /* Store the mapping information in the transport map */
563         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
564         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdServerMsgQ;
565         rmTransportMap[CD_TO_SERVER_MAP_ENTRY].remoteMsgQId = cdServerQId;
566         System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
567         
568         /* Open the Client messageQ from the Client Delegate */
569         do 
570         {
571             status = MessageQ_open(clientCdQueueName, &cdClientQId); 
572             /* 
573              *  Sleep for 1 clock tick to avoid inundating remote processor
574              *  with interrupts if open failed
575              */
576             if (status < 0) 
577             { 
578                 Task_sleep(1);
579             }
580         } while (status < 0);
581         System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
583         /* Register the Client with the RM Client Delegate Instance */
584         rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
585         rmTransportCfg.remoteInstName = &rmClientName[0];
586         /* Callouts already set so set them as invalid */
587         rmTransportCfg.transportCalloutsValid = false;
589         cdClientHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
591         /* Store the mapping information in the transport map */
592         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
593         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdClientMsgQ;
594         rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].remoteMsgQId = cdClientQId;
595         System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
596         
597         /* Open the Client Delegate messageQ from the Client */        
598         do 
599         {
600             status = MessageQ_open(cdClientQueueName, &clientCdQId); 
601             /* 
602              *  Sleep for 1 clock tick to avoid inundating remote processor
603              *  with interrupts if open failed
604              */
605             if (status < 0) 
606             { 
607                 Task_sleep(1);
608             }
609         } while (status < 0);
610         System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
612         /* Register the Client Delegate with the RM Client Instance */
613         rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
614         rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
615         /* Callouts already set so set them as invalid */
616         rmTransportCfg.transportCalloutsValid = false;
618         clientCdHandle = Rm_transportRegister(rmClientHandle, &rmTransportCfg);
620         /* Store the mapping information in the transport map */
621         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
622         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientCdMsgQ;
623         rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].remoteMsgQId = clientCdQId; 
624         System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
625     }
626     
627     /* Create the RM test task. */
628     System_printf("Core %d: Creating RM test task...\n", MultiProc_self());
629     Task_Params_init (&taskParams);
630     Task_create (testRmTsk, &taskParams, NULL);
633 /*
634  *  ======== main ========
635  *  Synchronizes all processors (in Ipc_start) and calls BIOS_start
636  */
637 Int main(Int argc, Char* argv[])
639     Rm_InitCfg rmInitCfg;
640     Task_Params taskParams;
641     Int status;
643     System_printf ("*********************************************************\n");
644     System_printf ("********************** RM Testing ***********************\n");
645     System_printf ("*********************************************************\n");
647     System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
649     /* Initialize the RM instances - RM must be initialized before anything else in the system
650      * Core 0: 1 RM Instance - RM Server
651      * Core 1: 2 RM Instances - RM Client Delegate
652      *                          RM Client
653      */
654     if (MultiProc_self()== 0)
655     {
656         /* Create the RM Server instance */
657         rmInitCfg.instName = &rmServerName[0];
658         rmInitCfg.instType = Rm_instType_SERVER;
659         /* SET TO NULL - FEATURES NOT ADDED YET */
660         rmInitCfg.globalResourceList = NULL;
661         rmInitCfg.startupPolicy = NULL;
663         /* Get the RM Server handle */
664         rmServerHandle = Rm_init(&rmInitCfg);
665         System_printf("Core %d: RM Server instance created\n", MultiProc_self());
666     }
667     else if (MultiProc_self()== 1)
668     {
669         /* Create the RM Client Delegate instance */
670         rmInitCfg.instName = &rmClientDelegateName[0];
671         rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
672         /* SET TO NULL - FEATURES NOT ADDED YET */
673         rmInitCfg.globalResourceList = NULL;
674         rmInitCfg.startupPolicy = NULL;
676         /* Get the RM Client Delegate handle */
677         rmClientDelegateHandle = Rm_init(&rmInitCfg);
678         System_printf("Core %d: RM Client Delegate instance created\n", MultiProc_self());
680         /* Create the RM Client instance */
681         rmInitCfg.instName = &rmClientName[0];
682         rmInitCfg.instType = Rm_instType_CLIENT;
683         /* SET TO NULL - FEATURES NOT ADDED YET */
684         rmInitCfg.globalResourceList = NULL;
685         rmInitCfg.startupPolicy = NULL;
687         /* Get the RM Client handle */
688         rmClientHandle = Rm_init(&rmInitCfg);
689         System_printf("Core %d: RM Client instance created\n", MultiProc_self());
690     }
692     /*  
693      *  Ipc_start() calls Ipc_attach() to synchronize all remote processors
694      *  because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
695      */
696     System_printf("Core %d: Starting IPC...\n", MultiProc_self());
697     status = Ipc_start();
698     if (status < 0) 
699     {
700         System_abort("Ipc_start failed\n");
701     }
703     /* Create the RM startup task */
704     System_printf("Core %d: Creating RM startup task...\n", MultiProc_self());
705     Task_Params_init (&taskParams);
706     startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL);
708     System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
709     BIOS_start();
711     return (0);