ef9adabe3bdc20460701143f2b4a1eec8771489b
1 /*
2 * Copyright (c) 2012-2013, 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 * */
33 /*
34 * ======== rm_test.c ========
35 * RM multicore test example
36 *
37 */
39 #include <c6x.h>
40 #include <xdc/std.h>
41 #include <stdio.h>
42 #include <string.h>
43 #include <stdbool.h>
45 /* -----------------------------------XDC.RUNTIME module Headers */
46 #include <xdc/runtime/System.h>
47 #include <xdc/runtime/IHeap.h>
49 /* ----------------------------------- IPC module Headers */
50 #include <ti/ipc/Ipc.h>
51 #include <ti/ipc/MessageQ.h>
52 #include <ti/ipc/HeapBufMP.h>
53 #include <ti/ipc/MultiProc.h>
55 /* ----------------------------------- BIOS6 module Headers */
56 #include <ti/sysbios/BIOS.h>
57 #include <ti/sysbios/knl/Task.h>
58 #include <ti/sysbios/family/c64p/Hwi.h>
60 /* ----------------------------------- Resource Manager Headers */
61 #include <ti/drv/rm/rm.h>
62 #include <ti/drv/rm/rm_osal.h>
63 #include <ti/drv/rm/rm_transport.h>
64 #include <ti/drv/rm/rm_services.h>
66 /* ----------------------------------- CSL Module Headers */
67 #include <ti/csl/csl_semAux.h>
68 #include <ti/csl/csl_cacheAux.h>
69 #include <ti/csl/csl_xmcAux.h>
71 /* ======== Task Handles ======== */
72 Task_Handle startupRmTskHandle;
73 Task_Handle testReceiveTskHandle;
74 Task_Handle testRmTskHandle;
76 /* ======== Application Heaps ======== */
77 #define RM_PKT_HEAP_NAME "rmHeapBuf"
78 HeapBufMP_Handle rmPktHeapHandle = NULL;
80 #define MSGQ_HEAP_NAME "msgQHeapBuf"
81 #define MSGQ_HEAP_ID 0
83 /* ======== RM Instance Names ======== */
84 Char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server";
85 Char rmClientDelegateName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate";
86 Char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
88 /* ======== RM DTB Files ======== */
89 extern const char rmGrl[];
90 extern const char rmGlobalPolicy[];
91 extern const char rmStaticPolicy[];
92 extern const char rmLinuxDtb[];
94 /* ======== RM IPC MessageQ Names ======== */
95 Char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue";
96 Char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue";
97 Char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue";
98 Char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue";
100 /* ======== Test Resource & NameServer Names ======== */
101 Char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions";
102 char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch";
103 Char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue";
104 Char resourceNameAifQ[RM_NAME_MAX_CHARS] = "aif-queue";
105 Char resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster";
106 Char resourceNameAifRxCh[RM_NAME_MAX_CHARS] = "aif-rx-ch";
107 Char resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
109 Char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
111 /* ======== RM Instance Handles ======== */
112 Rm_Handle rmServerHandle = NULL;
113 Rm_Handle rmClientDelegateHandle = NULL;
114 Rm_Handle rmClientHandle = NULL;
116 /* ======== RM Instance Service Ports ======== */
117 Rm_ServiceHandle *rmServerServiceHandle = NULL;
118 Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
119 Rm_ServiceHandle *rmClientServiceHandle = NULL;
121 /* ======== RM Transport Packet Definition ======== */
122 typedef struct {
123 MessageQ_MsgHeader msgQHeader;
124 /* Pointer to packet provided by RM */
125 Rm_Packet *rmPkt;
126 } MsgQ_RmPacket;
128 /* ======== RM Transport Mapping Tables for Application ======== */
129 /* Core 0 Map Entry Indices */
130 #define SERVER_TO_CD_MAP_ENTRY 0
131 /* Core 1 Map Entry Indicies */
132 #define CD_TO_SERVER_MAP_ENTRY 0
133 #define CD_TO_CLIENT_MAP_ENTRY 1
134 #define CLIENT_TO_CD_MAP_ENTRY 2
136 /* Max map entries across all cores */
137 #define MAX_MAPPING_ENTRIES 3
139 typedef struct {
140 Rm_TransportHandle transportHandle;
141 MessageQ_Handle receiveMsgQ;
142 } Transport_MapEntry;
144 /* Core 1 will have three mapping entries
145 * Two map entries for the Client Delegate
146 * One map entry for the Client */
147 Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
149 uint32_t waitForBlockingOperation = 0;
150 Rm_ServiceRespInfo responseInfo;
152 /* ======== RM Application Sync APIs ======== */
154 typedef struct {
155 uint32_t sem;
156 uint32_t pad[31];
157 } syncObj;
159 #pragma DATA_SECTION (testSyncObj, ".syncObj");
160 #pragma DATA_ALIGN (testSyncObj, 16)
161 syncObj testSyncObj;
163 /**
164 * @b Description
165 * @n
166 * The function is used to indicate that a block of memory is
167 * about to be accessed. If the memory block is cached then this
168 * indicates that the application would need to ensure that the
169 * cache is updated with the data from the actual memory.
170 *
171 * @param[in] ptr
172 * Address of memory block
173 *
174 * @param[in] size
175 * Size of memory block
176 *
177 * @retval
178 * Not Applicable
179 */
180 void beginMemAccess (void *ptr, uint32_t size)
181 {
182 uint32_t key;
184 key = Hwi_disable();
186 /* Cleanup the prefetch buffer also. */
187 CSL_XMC_invalidatePrefetchBuffer();
188 /* Invalidate L1D cache and wait until operation is complete.
189 * Use this approach if L2 cache is not enabled */
190 CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);
191 asm (" nop 4");
192 asm (" nop 4");
193 asm (" nop 4");
194 asm (" nop 4");
195 Hwi_restore(key);
196 }
198 /**
199 * @b Description
200 * @n
201 * The function is used to indicate that the block of memory has
202 * finished being accessed. If the memory block is cached then the
203 * application would need to ensure that the contents of the cache
204 * are updated immediately to the actual memory.
205 *
206 * @param[in] ptr
207 * Address of memory block
208 *
209 * @param[in] size
210 * Size of memory block
211 *
212 * @retval
213 * Not Applicable
214 */
215 void endMemAccess (void *ptr, uint32_t size)
216 {
217 uint32_t key;
219 key = Hwi_disable();
221 /* Writeback L1D cache and wait until operation is complete.
222 * Use this approach if L2 cache is not enabled */
223 CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);
224 asm (" nop 4");
225 asm (" nop 4");
226 asm (" nop 4");
227 asm (" nop 4");
228 Hwi_restore(key);
229 }
232 void initSyncObj(void)
233 {
234 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
235 testSyncObj.sem = 0;
236 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
237 }
239 void takeSyncObj(void)
240 {
241 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
242 testSyncObj.sem = 1;
243 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
244 }
246 void waitOnSyncObj(void)
247 {
248 do {
249 /* Yield for other tasks */
250 Task_yield();
251 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
252 } while (testSyncObj.sem == 1);
253 }
255 void releaseSyncObj(void)
256 {
257 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
258 testSyncObj.sem = 0;
259 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
260 }
262 /* ======== RM Application Transport APIs ======== */
264 Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
265 {
266 Rm_Packet *rmPkt = NULL;
267 MsgQ_RmPacket *rmMsg = NULL;
269 /* Allocate a messageQ message for containing the RM packet */
270 rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
271 if (rmMsg == NULL) {
272 System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
273 *pktHandle = NULL;
274 return(NULL);
275 }
276 else {
277 /* Create and attach RM packet to MessageQ message. All transports will allocate from the same heap */
278 rmPkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
279 rmPkt->pktLenBytes = pktSize;
280 endMemAccess((void *)rmPkt, rmPkt->pktLenBytes);
281 rmMsg->rmPkt = rmPkt;
282 *pktHandle = (Rm_PacketHandle)rmMsg;
283 }
284 return (rmPkt);
285 }
287 void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt)
288 {
289 uint32_t pktSize = pkt->pktLenBytes;
290 int32_t status;
292 /* All transports will free rmPkts to the same heap */
293 HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
295 status = MessageQ_free(rmMsgQMsg);
296 if (status < 0) {
297 System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", MultiProc_self());
298 }
299 }
301 int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
302 {
303 MessageQ_QueueId remoteQueueId = (MessageQ_QueueId)appTransport;
304 MsgQ_RmPacket *rmMsg = pktHandle;
305 int32_t status;
307 /* Write back data that was written by RM after alloc */
308 endMemAccess((void *)rmMsg->rmPkt, rmMsg->rmPkt->pktLenBytes);
310 /* Send the message to the remote side */
311 status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
312 if (status < 0) {
313 transportFree((MessageQ_Msg)rmMsg, rmMsg->rmPkt);
314 System_printf("Core %d: MessageQ_put had a failure/error in TransportSend: error: %d\n", MultiProc_self(),
315 status);
316 }
317 return (status);
318 }
320 void transportReceive (uint32_t transportMapEntry)
321 {
322 MessageQ_Handle receiveQ;
323 int32_t numPkts;
324 MessageQ_Msg rmMsg = NULL;
325 Rm_Packet *rmPkt = NULL;
326 int32_t status;
327 uint32_t i;
329 /* Check if any packets available */
330 receiveQ = rmTransportMap[transportMapEntry].receiveMsgQ;
331 numPkts = (int32_t) MessageQ_count(receiveQ);
333 /* Process all available packets */
334 for (i = 0; i < numPkts; i++) {
335 status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
336 if (status < 0) {
337 System_abort("This should not happen since timeout is forever\n");
338 }
339 if (rmMsg == NULL) {
340 System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
341 }
343 /* Extract the Rm_Packet from the RM msg */
344 rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
345 beginMemAccess((void *) rmPkt, rmPkt->pktLenBytes);
347 /* Provide packet to RM for processing */
348 if (status = Rm_receivePacket(rmTransportMap[transportMapEntry].transportHandle, rmPkt)) {
349 System_printf("Core %d: RM encountered error processing received packet: %d\n", MultiProc_self(), status);
350 }
352 /* Free RM packet buffer and messageQ message */
353 transportFree(rmMsg, rmPkt);
354 }
355 }
357 /*
358 * ======== testServiceCallback ========
359 * Application's callback function given to RM on service requests
360 */
361 void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
362 {
363 if (serviceResponse->serviceId == waitForBlockingOperation) {
364 waitForBlockingOperation = 0;
365 strcpy(responseInfo.resourceName, serviceResponse->resourceName);
366 responseInfo.resourceBase = serviceResponse->resourceBase;
367 responseInfo.resourceLength = serviceResponse->resourceLength;
368 responseInfo.serviceState = serviceResponse->serviceState;
369 }
370 else {
371 System_printf("Core %d: validation of static request with ID %d\n", MultiProc_self(),
372 serviceResponse->serviceId);
373 System_printf(" resource: %s, state: %d, base: %d, length: %d\n", serviceResponse->resourceName,
374 serviceResponse->serviceState,
375 serviceResponse->resourceBase,
376 serviceResponse->resourceLength);
377 }
378 }
380 bool blockForResponse(Rm_ServiceRespInfo *respInfo)
381 {
382 waitForBlockingOperation = respInfo->serviceId;
383 /* Block and wait for the response if the RM needed to perform a blocking operation
384 * to complete the request */
385 while(waitForBlockingOperation) {
386 /* Yield to receive task to see if there are any packets for RM instance */
387 Task_yield();
388 }
390 if ((respInfo->serviceState != RM_SERVICE_PROCESSING) &&
391 (respInfo->serviceState != RM_SERVICE_APPROVED) &&
392 (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) {
393 System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(),
394 respInfo->serviceState);
395 return(FALSE);
396 }
397 return(TRUE);
398 }
400 /*
401 * ======== testRmTsk ========
402 * RM cleanup task
403 */
404 void cleanupRmTsk(UArg arg0, UArg arg1)
405 {
406 int32_t result;
408 /* Delete the RM test task */
409 System_printf("Core %d: Deleting RM test task...\n", MultiProc_self());
410 if (testRmTskHandle) {
411 Task_delete(&testRmTskHandle);
412 /* Set the task handle to be NULL so that the delete only occurs once */
413 testRmTskHandle = NULL;
414 }
415 /* Delete the RM receive task */
416 System_printf("Core %d: Deleting RM receive task...\n", MultiProc_self());
417 if (testReceiveTskHandle) {
418 Task_delete(&testReceiveTskHandle);
419 /* Set the task handle to be NULL so that the delete only occurs once */
420 testReceiveTskHandle = NULL;
421 }
423 /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
424 if (MultiProc_self() == 0) {
425 Rm_serviceCloseHandle(rmServerServiceHandle);
427 Rm_transportUnregister(rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle);
429 result = Rm_delete(rmServerHandle, true);
430 if (result != RM_OK) {
431 System_printf("Core %d: RM server instance delete failed with error %d\n", MultiProc_self(), result);
432 }
433 }
434 else if (MultiProc_self() == 1) {
435 Rm_serviceCloseHandle(rmClientDelegateServiceHandle);
436 Rm_serviceCloseHandle(rmClientServiceHandle);
438 Rm_transportUnregister(rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle);
439 Rm_transportUnregister(rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle);
440 Rm_transportUnregister(rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle);
442 result = Rm_delete(rmClientDelegateHandle, true);
443 if (result != RM_OK) {
444 System_printf("Core %d: RM cd instance delete failed with error %d\n", MultiProc_self(), result);
445 }
446 result = Rm_delete(rmClientHandle, true);
447 if (result != RM_OK) {
448 System_printf("Core %d: RM client instance delete failed with error %d\n", MultiProc_self(), result);
449 }
450 }
452 BIOS_exit(0);
453 }
455 /*
456 * ======== testRmTsk ========
457 * RM test task
458 */
459 void testReceiveTsk(UArg arg0, UArg arg1)
460 {
461 while(1) {
462 if (MultiProc_self() == 0) {
463 transportReceive(SERVER_TO_CD_MAP_ENTRY);
464 }
465 else if (MultiProc_self() == 1) {
466 transportReceive(CD_TO_SERVER_MAP_ENTRY);
467 transportReceive(CD_TO_CLIENT_MAP_ENTRY);
468 transportReceive(CLIENT_TO_CD_MAP_ENTRY);
469 }
470 /* Yield for main test task */
471 Task_yield();
472 }
473 }
475 /*
476 * ======== testRmTsk ========
477 * RM test task
478 */
479 void testRmTsk(UArg arg0, UArg arg1)
480 {
481 Rm_ServiceReqInfo requestInfo;
482 Task_Params taskParams;
483 int32_t result;
485 /* Delete the RM startup task */
486 System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
487 if (startupRmTskHandle) {
488 Task_delete(&startupRmTskHandle);
489 /* Set the task handle to be NULL so that the delete only occurs once */
490 startupRmTskHandle = NULL;
491 }
493 /* Open service ports on all the RM instances to test service requests from the different
494 * RM instances */
495 if (MultiProc_self() == 0) {
496 rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
498 Rm_printInstanceStatus(rmServerHandle);
499 }
500 else if (MultiProc_self() == 1) {
501 /* CD and Client serviceHandles were allocated in main() for static allocations.
502 * just reuse */
504 Rm_printInstanceStatus(rmClientDelegateHandle);
505 Rm_printInstanceStatus(rmClientHandle);
506 }
508 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
509 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
511 System_printf("Core %d: Testing NameServer features...\n", MultiProc_self());
513 /* Use the service ports to test the service requests */
514 if (MultiProc_self() == 0) {
515 /* Issue the service request create a new NameServer object via the service port */
516 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
517 requestInfo.resourceName = resourceNameGpQ;
518 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
519 requestInfo.resourceLength = 1;
520 requestInfo.resourceAlignment = 0;
522 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
523 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
524 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
525 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
526 if (blockForResponse(&responseInfo)) {
527 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
528 rmServerName,
529 responseInfo.resourceName,
530 responseInfo.resourceBase,
531 responseInfo.resourceLength);
532 }
533 }
534 else {
535 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
536 responseInfo.serviceState);
537 }
539 /* Issue the service request create a new NameServer object via the service port */
540 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
541 requestInfo.resourceName = resourceNameGpQ;
542 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
543 requestInfo.resourceLength = 1;
544 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
546 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
547 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
548 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
549 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
550 if (blockForResponse(&responseInfo)) {
551 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
552 rmServerName,
553 responseInfo.resourceName,
554 responseInfo.resourceBase,
555 responseInfo.resourceLength);
556 }
557 }
558 else {
559 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
560 responseInfo.serviceState);
561 }
563 /* Issue the service request create a new NameServer object via the service port */
564 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
565 requestInfo.resourceName = resourceNameGpQ;
566 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
567 requestInfo.resourceLength = 1;
568 requestInfo.resourceAlignment = 200;
570 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
571 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
572 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
573 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
574 if (blockForResponse(&responseInfo)) {
575 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
576 rmServerName,
577 responseInfo.resourceName,
578 responseInfo.resourceBase,
579 responseInfo.resourceLength);
580 }
581 }
582 else {
583 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
584 responseInfo.serviceState);
585 }
587 // Rm_printResourceStatus(rmServerHandle);
590 /* Issue the service request create a new NameServer object via the service port */
591 requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
592 requestInfo.resourceName = resourceNameGpQ;
593 requestInfo.resourceBase = 1002;
594 requestInfo.resourceLength = 1;
595 requestInfo.resourceNsName = nameServerNameFavQ;
597 System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName);
598 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
599 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
600 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
601 if (blockForResponse(&responseInfo)) {
602 System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
603 rmServerName,
604 nameServerNameFavQ,
605 requestInfo.resourceBase,
606 requestInfo.resourceLength);
607 }
608 }
609 else {
610 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
611 responseInfo.serviceState);
612 }
614 /* Wait for Client Delegate and Client to retrieve resource via the name and allocate it */
615 waitOnSyncObj();
617 // Rm_printResourceStatus(rmServerHandle);
619 /* Wait for Client to free resource via the NameServer and delete the NameServer object. */
620 waitOnSyncObj();
622 // Rm_printResourceStatus(rmServerHandle);
624 /* Try to allocate the memory region taken by the Linux Kernel */
625 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
626 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
627 requestInfo.resourceName = resourceNameMemRegion;
628 requestInfo.resourceBase = 12;
629 requestInfo.resourceLength = 1;
631 System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName);
632 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
633 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
634 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
635 if (blockForResponse(&responseInfo)) {
636 System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
637 rmServerName,
638 requestInfo.resourceName,
639 requestInfo.resourceBase,
640 requestInfo.resourceLength);
641 }
642 }
643 else {
644 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
645 responseInfo.serviceState);
646 }
648 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
649 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
650 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
651 requestInfo.resourceName = resourceNameAifRxCh;
652 requestInfo.resourceBase = 14;
653 requestInfo.resourceLength = 5;
655 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
656 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
657 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
658 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
659 if (blockForResponse(&responseInfo)) {
660 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
661 rmServerName,
662 requestInfo.resourceName,
663 requestInfo.resourceBase,
664 requestInfo.resourceLength);
665 }
666 }
667 else {
668 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
669 responseInfo.serviceState);
670 }
671 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
672 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
673 requestInfo.resourceName = resourceNameAifRxCh;
674 requestInfo.resourceBase = 19;
675 requestInfo.resourceLength = 31;
677 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
678 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
679 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
680 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
681 if (blockForResponse(&responseInfo)) {
682 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
683 rmServerName,
684 requestInfo.resourceName,
685 requestInfo.resourceBase,
686 requestInfo.resourceLength);
687 }
688 }
689 else {
690 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
691 responseInfo.serviceState);
692 }
694 /* Wait for Client and Client Delegate to do their allocates */
695 waitOnSyncObj();
697 // Rm_printResourceStatus(rmServerHandle);
699 /* Free resources to show tree handling of different frees */
700 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
701 requestInfo.type = Rm_service_RESOURCE_FREE;
702 requestInfo.resourceName = resourceNameAifRxCh;
703 requestInfo.resourceBase = 25;
704 requestInfo.resourceLength = 3;
706 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
707 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
708 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
709 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
710 if (blockForResponse(&responseInfo)) {
711 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
712 rmServerName,
713 requestInfo.resourceName,
714 requestInfo.resourceBase,
715 requestInfo.resourceLength);
716 }
717 }
718 else {
719 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
720 responseInfo.serviceState);
721 }
723 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
724 requestInfo.type = Rm_service_RESOURCE_FREE;
725 requestInfo.resourceName = resourceNameAifRxCh;
726 requestInfo.resourceBase = 34;
727 requestInfo.resourceLength = 3;
729 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
730 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
731 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
732 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
733 if (blockForResponse(&responseInfo)) {
734 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
735 rmServerName,
736 requestInfo.resourceName,
737 requestInfo.resourceBase,
738 requestInfo.resourceLength);
739 }
740 }
741 else {
742 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
743 responseInfo.serviceState);
744 }
746 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
747 requestInfo.type = Rm_service_RESOURCE_FREE;
748 requestInfo.resourceName = resourceNameAifRxCh;
749 requestInfo.resourceBase = 28;
750 requestInfo.resourceLength = 6;
752 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
753 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
754 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
755 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
756 if (blockForResponse(&responseInfo)) {
757 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
758 rmServerName,
759 requestInfo.resourceName,
760 requestInfo.resourceBase,
761 requestInfo.resourceLength);
762 }
763 }
764 else {
765 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
766 responseInfo.serviceState);
767 }
769 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
770 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
771 requestInfo.resourceName = resourceNameAifRxCh;
772 requestInfo.resourceBase = 53;
773 requestInfo.resourceLength = 2;
775 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
776 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
777 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
778 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
779 if (blockForResponse(&responseInfo)) {
780 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
781 rmServerName,
782 requestInfo.resourceName,
783 requestInfo.resourceBase,
784 requestInfo.resourceLength);
785 }
786 }
787 else {
788 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
789 responseInfo.serviceState);
790 }
791 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
792 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
793 requestInfo.resourceName = resourceNameAifRxCh;
794 requestInfo.resourceBase = 2;
795 requestInfo.resourceLength = 2;
797 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
798 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
799 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
800 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
801 if (blockForResponse(&responseInfo)) {
802 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
803 rmServerName,
804 requestInfo.resourceName,
805 requestInfo.resourceBase,
806 requestInfo.resourceLength);
807 }
808 }
809 else {
810 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
811 responseInfo.serviceState);
812 }
814 // Rm_printResourceStatus(rmServerHandle);
816 /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
817 waitOnSyncObj();
819 // Rm_printResourceStatus(rmServerHandle);
821 /* Test allocation of a resource twice from the same instance with init and use privileges. Both
822 * should be approved but the instance should only be mentioned once in the resource's owner list */
823 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
824 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
825 requestInfo.resourceName = resourceNameGpQ;
826 requestInfo.resourceBase = 6543;
827 requestInfo.resourceLength = 10;
829 System_printf("Core %d: %s Allocating resource for init...\n", MultiProc_self(), rmServerName);
830 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
831 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
832 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
833 if (blockForResponse(&responseInfo)) {
834 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
835 rmServerName,
836 requestInfo.resourceName,
837 requestInfo.resourceBase,
838 requestInfo.resourceLength);
839 }
840 }
841 else {
842 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
843 responseInfo.serviceState);
844 }
845 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
846 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
847 requestInfo.resourceName = resourceNameGpQ;
848 requestInfo.resourceBase = 6543;
849 requestInfo.resourceLength = 10;
851 System_printf("Core %d: %s Allocating same resource for use...\n", MultiProc_self(), rmServerName);
852 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
853 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
854 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
855 if (blockForResponse(&responseInfo)) {
856 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
857 rmServerName,
858 requestInfo.resourceName,
859 requestInfo.resourceBase,
860 requestInfo.resourceLength);
861 }
862 }
863 else {
864 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
865 responseInfo.serviceState);
866 }
868 // Rm_printResourceStatus(rmServerHandle);
870 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
871 * Rm_Client */
872 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
873 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
874 requestInfo.resourceName = resourceNameInfraQ;
875 requestInfo.resourceBase = 805;
876 requestInfo.resourceLength = 1;
878 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmServerName);
879 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
880 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
881 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
882 if (blockForResponse(&responseInfo)) {
883 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
884 rmServerName,
885 requestInfo.resourceName,
886 requestInfo.resourceBase,
887 requestInfo.resourceLength);
888 }
889 }
890 else {
891 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
892 responseInfo.serviceState);
893 }
895 Rm_printResourceStatus(rmServerHandle);
896 }
897 else if (MultiProc_self() == 1) {
898 /* Issue the service request for the resources tied to the name via the service port */
899 requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME;
900 requestInfo.resourceNsName = nameServerNameFavQ;
901 requestInfo.callback.serviceCallback = testServiceCallback;
903 System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
904 rmClientDelegateName);
905 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
906 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
907 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
908 if (blockForResponse(&responseInfo)) {
909 System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
910 rmClientDelegateName,
911 nameServerNameFavQ,
912 responseInfo.resourceBase,
913 responseInfo.resourceLength);
914 }
915 }
916 else {
917 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
918 responseInfo.serviceState);
919 }
921 /* Allocate the resources via the service port from the Client */
922 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
923 requestInfo.resourceName = responseInfo.resourceName;
924 requestInfo.resourceBase = responseInfo.resourceBase;
925 requestInfo.resourceLength = responseInfo.resourceLength;
926 requestInfo.resourceNsName = NULL;
927 requestInfo.callback.serviceCallback = testServiceCallback;
929 System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
930 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
931 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
932 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
933 if (blockForResponse(&responseInfo)) {
934 System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
935 rmClientName,
936 nameServerNameFavQ,
937 responseInfo.resourceBase,
938 responseInfo.resourceLength);
939 }
940 }
941 else {
942 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
943 responseInfo.serviceState);
944 }
946 /* Release the syncObj so Server can print results of NameServer object add and resource allocate */
947 releaseSyncObj();
949 /* Take the syncObj to free the name resource via the name, rather than the base+length */
950 takeSyncObj();
952 /* Free the named resource using the name via the service port from the Client */
953 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
954 requestInfo.type = Rm_service_RESOURCE_FREE;
955 requestInfo.resourceNsName = nameServerNameFavQ;
956 requestInfo.callback.serviceCallback = testServiceCallback;
958 System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
959 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
960 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
961 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
962 if (blockForResponse(&responseInfo)) {
963 System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
964 rmClientName,
965 nameServerNameFavQ);
966 }
967 }
968 else {
969 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
970 responseInfo.serviceState);
971 }
973 /* Delete the name object from the NameServer */
974 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
975 requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME;
976 requestInfo.resourceNsName = nameServerNameFavQ;
977 requestInfo.callback.serviceCallback = testServiceCallback;
979 System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
980 rmClientName,
981 nameServerNameFavQ);
982 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
983 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
984 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
985 if (blockForResponse(&responseInfo)) {
986 System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
987 rmClientName,
988 nameServerNameFavQ);
989 }
990 }
991 else {
992 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
993 responseInfo.serviceState);
994 }
996 /* Release the syncObj so Server can print results of resource free and NameServer object delete. */
997 releaseSyncObj();
999 /* Take the syncObj to allocate resources for testing resource tree interactions. */
1000 takeSyncObj();
1002 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
1003 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1004 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1005 requestInfo.resourceName = resourceNameAifRxCh;
1006 requestInfo.resourceBase = 0;
1007 requestInfo.resourceLength = 6;
1008 requestInfo.callback.serviceCallback = testServiceCallback;
1010 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1011 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1012 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1013 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1014 if (blockForResponse(&responseInfo)) {
1015 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1016 rmClientName,
1017 requestInfo.resourceName,
1018 requestInfo.resourceBase,
1019 requestInfo.resourceLength);
1020 }
1021 }
1022 else {
1023 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1024 responseInfo.serviceState);
1025 }
1027 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1028 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1029 requestInfo.resourceName = resourceNameAifRxCh;
1030 requestInfo.resourceBase = 50;
1031 requestInfo.resourceLength = 7;
1032 requestInfo.callback.serviceCallback = testServiceCallback;
1034 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
1035 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1036 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1037 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1038 if (blockForResponse(&responseInfo)) {
1039 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1040 rmClientDelegateName,
1041 requestInfo.resourceName,
1042 requestInfo.resourceBase,
1043 requestInfo.resourceLength);
1044 }
1045 }
1046 else {
1047 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1048 responseInfo.serviceState);
1049 }
1051 /* Release the syncObj so Server can print results of resource allocations */
1052 releaseSyncObj();
1054 /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */
1055 takeSyncObj();
1057 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1058 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1059 requestInfo.resourceName = resourceNameAccumCh;
1060 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1061 requestInfo.resourceLength = 5;
1062 requestInfo.resourceAlignment = 4;
1063 requestInfo.callback.serviceCallback = testServiceCallback;
1065 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
1066 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1067 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1068 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1069 if (blockForResponse(&responseInfo)) {
1070 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1071 rmClientDelegateName,
1072 responseInfo.resourceName,
1073 responseInfo.resourceBase,
1074 responseInfo.resourceLength);
1075 }
1076 }
1077 else {
1078 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1079 responseInfo.serviceState);
1080 }
1082 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1083 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1084 requestInfo.resourceName = resourceNameAccumCh;
1085 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1086 requestInfo.resourceLength = 2;
1087 requestInfo.resourceAlignment = 1;
1088 requestInfo.callback.serviceCallback = testServiceCallback;
1090 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1091 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1092 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1093 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1094 if (blockForResponse(&responseInfo)) {
1095 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1096 rmClientName,
1097 responseInfo.resourceName,
1098 responseInfo.resourceBase,
1099 responseInfo.resourceLength);
1100 }
1101 }
1102 else {
1103 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1104 responseInfo.serviceState);
1105 }
1107 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1108 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1109 requestInfo.resourceName = resourceNameAccumCh;
1110 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1111 requestInfo.resourceLength = 2;
1112 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
1113 requestInfo.callback.serviceCallback = testServiceCallback;
1115 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1116 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1117 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1118 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1119 if (blockForResponse(&responseInfo)) {
1120 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1121 rmClientName,
1122 responseInfo.resourceName,
1123 responseInfo.resourceBase,
1124 responseInfo.resourceLength);
1125 }
1126 }
1127 else {
1128 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1129 responseInfo.serviceState);
1130 }
1132 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
1133 * Rm_Client */
1134 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1135 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1136 requestInfo.resourceName = resourceNameInfraQ;
1137 requestInfo.resourceBase = 800;
1138 requestInfo.resourceLength = 1;
1139 requestInfo.callback.serviceCallback = testServiceCallback;
1141 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmClientName);
1142 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1143 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1144 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1145 if (blockForResponse(&responseInfo)) {
1146 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
1147 rmClientName,
1148 requestInfo.resourceName,
1149 requestInfo.resourceBase,
1150 requestInfo.resourceLength);
1151 }
1152 }
1153 else {
1154 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1155 responseInfo.serviceState);
1156 }
1158 /* Attempt to request a service from an instance that requires a blocking operation to satisfy
1159 * the request without providing a callback function. */
1160 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1161 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1162 requestInfo.resourceName = resourceNameGpQ;
1163 requestInfo.resourceBase = 7000;
1164 requestInfo.resourceLength = 1;
1166 System_printf("Core %d: %s Attempting service request without callback function...\n", MultiProc_self(), rmClientName);
1167 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1168 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1169 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1170 if (blockForResponse(&responseInfo)) {
1171 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
1172 rmClientName,
1173 requestInfo.resourceName,
1174 requestInfo.resourceBase,
1175 requestInfo.resourceLength);
1176 }
1177 }
1178 else {
1179 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1180 responseInfo.serviceState);
1181 }
1183 /* Release the syncObj so Server can print results of resource allocations */
1184 releaseSyncObj();
1185 }
1187 System_printf("Core %d: Testing is complete\n", MultiProc_self());
1189 /* Create the RM cleanup task. */
1190 System_printf("Core %d: Creating RM cleanup task...\n", MultiProc_self());
1191 Task_Params_init (&taskParams);
1192 Task_create (cleanupRmTsk, &taskParams, NULL);
1193 }
1195 /*
1196 * ======== startupRmTsk ========
1197 * Configures application transports and registers them with RM
1198 */
1199 Void startupRmTsk(UArg arg0, UArg arg1)
1200 {
1201 MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
1202 MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
1203 Int status, i;
1204 HeapBufMP_Handle msgQHeapHandle;
1205 HeapBufMP_Params heapBufParams;
1206 Rm_TransportCfg rmTransportCfg;
1207 int32_t result = 0;
1208 Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
1209 Task_Params taskParams;
1211 if (MultiProc_self() == 1) {
1212 /* Take the syncObj on core 1, preparing for RM testing */
1213 takeSyncObj();
1214 }
1216 /* Initialize the transport map */
1217 for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
1218 rmTransportMap[i].transportHandle = NULL;
1219 }
1221 if (MultiProc_self() == 0) {
1222 /* Create the heap that will be used to allocate RM messages. This
1223 * heap is a multi-processor heap. It will be shared amongst
1224 * all RM instances. */
1225 HeapBufMP_Params_init(&heapBufParams);
1226 heapBufParams.regionId = 0;
1227 heapBufParams.name = RM_PKT_HEAP_NAME;
1228 heapBufParams.numBlocks = 64;
1229 heapBufParams.blockSize = sizeof(Rm_Packet);
1230 rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
1231 if (rmPktHeapHandle == NULL) {
1232 System_abort("HeapBufMP_create failed for RM packet heap\n" );
1233 }
1234 System_printf("Core %d: RM packet heap created\n", MultiProc_self());
1236 /* Create the heap that will be used to allocate messageQ messages. */
1237 HeapBufMP_Params_init(&heapBufParams);
1238 heapBufParams.regionId = 0;
1239 heapBufParams.name = MSGQ_HEAP_NAME;
1240 heapBufParams.numBlocks = 64;
1241 heapBufParams.blockSize = sizeof(MsgQ_RmPacket);
1242 msgQHeapHandle = HeapBufMP_create(&heapBufParams);
1243 if (msgQHeapHandle == NULL) {
1244 System_abort("HeapBufMP_create failed MessageQ message heap\n" );
1245 }
1246 System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
1247 }
1248 else {
1249 /* Open the heaps created by the other processor. Loop until opened. */
1250 do {
1251 status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
1252 /*
1253 * Sleep for 1 clock tick to avoid inundating remote processor
1254 * with interrupts if open failed
1255 */
1256 if (status < 0) {
1257 Task_sleep(1);
1258 }
1259 } while (status < 0);
1260 System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
1262 do {
1263 status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
1264 /*
1265 * Sleep for 1 clock tick to avoid inundating remote processor
1266 * with interrupts if open failed
1267 */
1268 if (status < 0) {
1269 Task_sleep(1);
1270 }
1271 } while (status < 0);
1272 System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
1273 }
1275 /* Register the MessageQ heap with MessageQ */
1276 MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
1278 /* Create the messageQ's for each RM instance connection
1279 * Need four queues. Topology will be:
1280 * RM Server <---> RM Client Delegate <---> RM Client
1281 * 1 queues on RM Server
1282 * 2 queues on RM Client Delegate
1283 * 1 queues on RM Client */
1284 if (MultiProc_self() == 0) {
1285 serverFromCdMsgQ = MessageQ_create(serverFromCdQueueName, NULL);
1286 if (serverFromCdMsgQ == NULL) {
1287 System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
1288 }
1289 System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1290 }
1291 else if (MultiProc_self() == 1) {
1292 cdFromServerMsgQ = MessageQ_create(cdFromServerQueueName, NULL);
1293 if (cdFromServerMsgQ == NULL) {
1294 System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
1295 }
1296 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
1298 cdFromClientMsgQ = MessageQ_create(cdFromClientQueueName, NULL);
1299 if (cdFromClientMsgQ == NULL) {
1300 System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
1301 }
1302 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
1304 clientFromCdMsgQ = MessageQ_create(clientFromCdQueueName, NULL);
1305 if (clientFromCdMsgQ == NULL)
1306 {
1307 System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
1308 }
1309 System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1310 }
1312 /* Open the remote message queues. Also register the RM transports with each RM instance */
1313 if (MultiProc_self() == 0) {
1314 /* Open the Client Delegate messageQ from the Server */
1315 do {
1316 status = MessageQ_open(cdFromServerQueueName, &serverToCdQId);
1317 /*
1318 * Sleep for 1 clock tick to avoid inundating remote processor
1319 * with interrupts if open failed
1320 */
1321 if (status < 0) {
1322 Task_sleep(1);
1323 }
1324 } while (status < 0);
1325 System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
1327 /* Register the Client Delegate with the RM Server Instance */
1328 rmTransportCfg.rmHandle = rmServerHandle;
1329 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCdQId;
1330 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1331 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1332 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1333 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1334 serverCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1336 /* Store the mapping information in the transport map */
1337 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
1338 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ;
1339 System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
1340 }
1341 else if (MultiProc_self() == 1) {
1342 /* Open the Server messageQ from the Client Delegate */
1343 do {
1344 status = MessageQ_open(serverFromCdQueueName, &cdToServerQId);
1345 /*
1346 * Sleep for 1 clock tick to avoid inundating remote processor
1347 * with interrupts if open failed
1348 */
1349 if (status < 0) {
1350 Task_sleep(1);
1351 }
1352 } while (status < 0);
1353 System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
1355 /* Register the Server with the RM Client Delegate Instance */
1356 rmTransportCfg.rmHandle = rmClientDelegateHandle;
1357 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToServerQId;
1358 rmTransportCfg.remoteInstType = Rm_instType_SERVER;
1359 rmTransportCfg.remoteInstName = &rmServerName[0];
1360 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1361 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1362 cdServerHandle = Rm_transportRegister(&rmTransportCfg, &result);
1364 /* Store the mapping information in the transport map */
1365 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
1366 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ;
1367 System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
1369 /* Open the Client messageQ from the Client Delegate */
1370 do {
1371 status = MessageQ_open(clientFromCdQueueName, &cdToClientQId);
1372 /*
1373 * Sleep for 1 clock tick to avoid inundating remote processor
1374 * with interrupts if open failed
1375 */
1376 if (status < 0) {
1377 Task_sleep(1);
1378 }
1379 } while (status < 0);
1380 System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
1382 /* Register the Client with the RM Client Delegate Instance */
1383 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClientQId;
1384 rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
1385 rmTransportCfg.remoteInstName = &rmClientName[0];
1386 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1387 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1388 cdClientHandle = Rm_transportRegister(&rmTransportCfg, &result);
1390 /* Store the mapping information in the transport map */
1391 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
1392 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ;
1393 System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
1395 /* Open the Client Delegate messageQ from the Client */
1396 do {
1397 status = MessageQ_open(cdFromClientQueueName, &clientToCdQId);
1398 /*
1399 * Sleep for 1 clock tick to avoid inundating remote processor
1400 * with interrupts if open failed
1401 */
1402 if (status < 0) {
1403 Task_sleep(1);
1404 }
1405 } while (status < 0);
1406 System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
1408 /* Register the Client Delegate with the RM Client Instance */
1409 rmTransportCfg.rmHandle = rmClientHandle;
1410 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCdQId;
1411 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1412 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1413 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1414 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1415 clientCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1417 /* Store the mapping information in the transport map */
1418 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
1419 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ;
1420 System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
1421 }
1423 /* Create the RM receive task. */
1424 System_printf("Core %d: Creating RM receive task...\n", MultiProc_self());
1425 Task_Params_init (&taskParams);
1426 testReceiveTskHandle = Task_create (testReceiveTsk, &taskParams, NULL);
1429 /* Create the RM test task. */
1430 System_printf("Core %d: Creating RM test task...\n", MultiProc_self());
1431 Task_Params_init (&taskParams);
1432 testRmTskHandle = Task_create (testRmTsk, &taskParams, NULL);
1433 }
1435 /*
1436 * ======== main ========
1437 * Synchronizes all processors (in Ipc_start) and calls BIOS_start
1438 */
1439 Int main(Int argc, Char* argv[])
1440 {
1441 Rm_InitCfg rmInitCfg;
1442 Task_Params taskParams;
1443 Int status;
1444 Rm_ServiceReqInfo requestInfo;
1445 int32_t result;
1447 System_printf ("*********************************************************\n");
1448 System_printf ("********************** RM Testing ***********************\n");
1449 System_printf ("*********************************************************\n");
1451 System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1453 /* Initialize the RM instances - RM must be initialized before anything else in the system
1454 * Core 0: 1 RM Instance - RM Server
1455 * Core 1: 2 RM Instances - RM Client Delegate
1456 * RM Client
1457 */
1458 if (MultiProc_self()== 0) {
1459 initSyncObj();
1461 /* Create the Server instance */
1462 rmInitCfg.instName = &rmServerName[0];
1463 rmInitCfg.instType = Rm_instType_SERVER;
1464 rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGrl;
1465 rmInitCfg.instCfg.serverCfg.linuxDtb = (void *)rmLinuxDtb;
1466 rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
1467 rmServerHandle = Rm_init(&rmInitCfg, &result);
1468 System_printf("Core %d: RM Server instance created. Result = %d\n", MultiProc_self(), result);
1470 Rm_printResourceStatus(rmServerHandle);
1471 }
1472 else if (MultiProc_self()== 1) {
1473 /* Create the RM Client Delegate instance */
1474 rmInitCfg.instName = &rmClientDelegateName[0];
1475 rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
1476 rmInitCfg.instCfg.cdCfg.staticPolicy = (void *)rmStaticPolicy;
1477 rmClientDelegateHandle = Rm_init(&rmInitCfg, &result);
1478 System_printf("Core %d: RM Client Delegate instance created. Result = %d\n", MultiProc_self(), result);
1480 /* Create the RM Client instance */
1481 rmInitCfg.instName = &rmClientName[0];
1482 rmInitCfg.instType = Rm_instType_CLIENT;
1483 rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
1484 rmClientHandle = Rm_init(&rmInitCfg, &result);
1485 System_printf("Core %d: RM Client instance created. Result = %d\n", MultiProc_self(), result);
1487 /* Open service handles on the CD and Client to test static allocations */
1488 rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result);
1489 rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
1491 /* Static allocations */
1492 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1493 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1494 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1495 requestInfo.resourceName = resourceNameQosCluster;
1496 requestInfo.resourceBase = 0;
1497 requestInfo.resourceLength = 1;
1498 requestInfo.callback.serviceCallback = testServiceCallback;
1500 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1501 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1502 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1503 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1504 rmClientDelegateName,
1505 resourceNameQosCluster,
1506 responseInfo.resourceBase,
1507 responseInfo.resourceLength);
1508 }
1509 else {
1510 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1511 responseInfo.serviceState);
1512 }
1514 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1515 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1516 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1517 requestInfo.resourceName = resourceNameQosCluster;
1518 requestInfo.resourceBase = 2;
1519 requestInfo.resourceLength = 1;
1520 requestInfo.callback.serviceCallback = testServiceCallback;
1522 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1523 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1524 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1525 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1526 rmClientName,
1527 resourceNameQosCluster,
1528 responseInfo.resourceBase,
1529 responseInfo.resourceLength);
1530 }
1531 else {
1532 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1533 responseInfo.serviceState);
1534 }
1536 /* Next request should return error */
1537 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1538 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1539 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1540 requestInfo.resourceName = resourceNameQosCluster;
1541 requestInfo.resourceBase = 1;
1542 requestInfo.resourceLength = 1;
1543 requestInfo.callback.serviceCallback = testServiceCallback;
1545 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1546 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1547 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1548 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1549 rmClientName,
1550 resourceNameQosCluster,
1551 responseInfo.resourceBase,
1552 responseInfo.resourceLength);
1553 }
1554 else {
1555 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1556 responseInfo.serviceState);
1557 }
1559 /* Allocated shared resource to both CD and Client using static policy */
1560 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1561 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1562 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1563 requestInfo.resourceName = resourceNameAifQ;
1564 requestInfo.resourceBase = 525;
1565 requestInfo.resourceLength = 1;
1566 requestInfo.callback.serviceCallback = testServiceCallback;
1568 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1569 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1570 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1571 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1572 rmClientDelegateName,
1573 resourceNameAifQ,
1574 responseInfo.resourceBase,
1575 responseInfo.resourceLength);
1576 }
1577 else {
1578 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1579 responseInfo.serviceState);
1580 }
1582 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1583 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1584 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1585 requestInfo.resourceName = resourceNameAifQ;
1586 requestInfo.resourceBase = 525;
1587 requestInfo.resourceLength = 1;
1588 requestInfo.callback.serviceCallback = testServiceCallback;
1590 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1591 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1592 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1593 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1594 rmClientName,
1595 resourceNameAifQ,
1596 responseInfo.resourceBase,
1597 responseInfo.resourceLength);
1598 }
1599 else {
1600 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1601 responseInfo.serviceState);
1602 }
1603 }
1605 System_printf("Core %d: Starting IPC...\n", MultiProc_self());
1606 status = Ipc_start();
1607 if (status < 0) {
1608 System_abort("Ipc_start failed\n");
1609 }
1611 /* Create the RM startup task */
1612 System_printf("Core %d: Creating RM startup task...\n", MultiProc_self());
1613 Task_Params_init (&taskParams);
1614 startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL);
1616 System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
1617 BIOS_start();
1619 return (0);
1620 }