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 IPC MessageQ Names ======== */
89 Char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue";
90 Char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue";
91 Char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue";
92 Char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue";
94 /* ======== Test Resource & NameServer Names ======== */
95 Char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions";
96 char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch";
97 Char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue";
98 Char resourceNameAifQ[RM_NAME_MAX_CHARS] = "aif-queue";
99 Char resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster";
100 Char resourceNameAifRxCh[RM_NAME_MAX_CHARS] = "aif-rx-ch";
101 Char resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
103 Char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
105 /* ======== RM Instance Handles ======== */
106 Rm_Handle rmServerHandle = NULL;
107 Rm_Handle rmClientDelegateHandle = NULL;
108 Rm_Handle rmClientHandle = NULL;
110 /* ======== RM Instance Service Ports ======== */
111 Rm_ServiceHandle *rmServerServiceHandle = NULL;
112 Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
113 Rm_ServiceHandle *rmClientServiceHandle = NULL;
115 /* ======== RM Transport Packet Definition ======== */
116 typedef struct {
117 MessageQ_MsgHeader msgQHeader;
118 /* Pointer to packet provided by RM */
119 Rm_Packet *rmPkt;
120 } MsgQ_RmPacket;
122 /* ======== RM Transport Mapping Tables for Application ======== */
123 /* Core 0 Map Entry Indices */
124 #define SERVER_TO_CD_MAP_ENTRY 0
125 /* Core 1 Map Entry Indicies */
126 #define CD_TO_SERVER_MAP_ENTRY 0
127 #define CD_TO_CLIENT_MAP_ENTRY 1
128 #define CLIENT_TO_CD_MAP_ENTRY 2
130 /* Max map entries across all cores */
131 #define MAX_MAPPING_ENTRIES 3
133 typedef struct {
134 Rm_TransportHandle transportHandle;
135 MessageQ_Handle receiveMsgQ;
136 } Transport_MapEntry;
138 /* Core 1 will have three mapping entries
139 * Two map entries for the Client Delegate
140 * One map entry for the Client */
141 Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
143 uint32_t waitForBlockingOperation = 0;
144 Rm_ServiceRespInfo responseInfo;
146 /* ======== RM Application Sync APIs ======== */
148 typedef struct {
149 uint32_t sem;
150 uint32_t pad[31];
151 } syncObj;
153 #pragma DATA_SECTION (testSyncObj, ".syncObj");
154 #pragma DATA_ALIGN (testSyncObj, 16)
155 syncObj testSyncObj;
157 /**
158 * @b Description
159 * @n
160 * The function is used to indicate that a block of memory is
161 * about to be accessed. If the memory block is cached then this
162 * indicates that the application would need to ensure that the
163 * cache is updated with the data from the actual memory.
164 *
165 * @param[in] ptr
166 * Address of memory block
167 *
168 * @param[in] size
169 * Size of memory block
170 *
171 * @retval
172 * Not Applicable
173 */
174 void beginMemAccess (void *ptr, uint32_t size)
175 {
176 uint32_t key;
178 key = Hwi_disable();
180 /* Cleanup the prefetch buffer also. */
181 CSL_XMC_invalidatePrefetchBuffer();
182 /* Invalidate L1D cache and wait until operation is complete.
183 * Use this approach if L2 cache is not enabled */
184 CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);
185 asm (" nop 4");
186 asm (" nop 4");
187 asm (" nop 4");
188 asm (" nop 4");
189 Hwi_restore(key);
190 }
192 /**
193 * @b Description
194 * @n
195 * The function is used to indicate that the block of memory has
196 * finished being accessed. If the memory block is cached then the
197 * application would need to ensure that the contents of the cache
198 * are updated immediately to the actual memory.
199 *
200 * @param[in] ptr
201 * Address of memory block
202 *
203 * @param[in] size
204 * Size of memory block
205 *
206 * @retval
207 * Not Applicable
208 */
209 void endMemAccess (void *ptr, uint32_t size)
210 {
211 uint32_t key;
213 key = Hwi_disable();
215 /* Writeback L1D cache and wait until operation is complete.
216 * Use this approach if L2 cache is not enabled */
217 CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);
218 asm (" nop 4");
219 asm (" nop 4");
220 asm (" nop 4");
221 asm (" nop 4");
222 Hwi_restore(key);
223 }
226 void initSyncObj(void)
227 {
228 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
229 testSyncObj.sem = 0;
230 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
231 }
233 void takeSyncObj(void)
234 {
235 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
236 testSyncObj.sem = 1;
237 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
238 }
240 void waitOnSyncObj(void)
241 {
242 do {
243 /* Yield for other tasks */
244 Task_yield();
245 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
246 } while (testSyncObj.sem == 1);
247 }
249 void releaseSyncObj(void)
250 {
251 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
252 testSyncObj.sem = 0;
253 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
254 }
256 /* ======== RM Application Transport APIs ======== */
258 Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
259 {
260 Rm_Packet *rmPkt = NULL;
261 MsgQ_RmPacket *rmMsg = NULL;
263 /* Allocate a messageQ message for containing the RM packet */
264 rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
265 if (rmMsg == NULL) {
266 System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
267 *pktHandle = NULL;
268 return(NULL);
269 }
270 else {
271 /* Create and attach RM packet to MessageQ message. All transports will allocate from the same heap */
272 rmPkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
273 rmPkt->pktLenBytes = pktSize;
274 endMemAccess((void *)rmPkt, rmPkt->pktLenBytes);
275 rmMsg->rmPkt = rmPkt;
276 *pktHandle = (Rm_PacketHandle)rmMsg;
277 }
278 return (rmPkt);
279 }
281 void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt)
282 {
283 uint32_t pktSize = pkt->pktLenBytes;
284 int32_t status;
286 /* All transports will free rmPkts to the same heap */
287 HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
289 status = MessageQ_free(rmMsgQMsg);
290 if (status < 0) {
291 System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", MultiProc_self());
292 }
293 }
295 int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
296 {
297 MessageQ_QueueId remoteQueueId = (MessageQ_QueueId)appTransport;
298 MsgQ_RmPacket *rmMsg = pktHandle;
299 int32_t status;
301 /* Write back data that was written by RM after alloc */
302 endMemAccess((void *)rmMsg->rmPkt, rmMsg->rmPkt->pktLenBytes);
304 /* Send the message to the remote side */
305 status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
306 if (status < 0) {
307 transportFree((MessageQ_Msg)rmMsg, rmMsg->rmPkt);
308 System_printf("Core %d: MessageQ_put had a failure/error in TransportSend: error: %d\n", MultiProc_self(),
309 status);
310 }
311 return (status);
312 }
314 void transportReceive (uint32_t transportMapEntry)
315 {
316 MessageQ_Handle receiveQ;
317 int32_t numPkts;
318 MessageQ_Msg rmMsg = NULL;
319 Rm_Packet *rmPkt = NULL;
320 int32_t status;
321 uint32_t i;
323 /* Check if any packets available */
324 receiveQ = rmTransportMap[transportMapEntry].receiveMsgQ;
325 numPkts = (int32_t) MessageQ_count(receiveQ);
327 /* Process all available packets */
328 for (i = 0; i < numPkts; i++) {
329 status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
330 if (status < 0) {
331 System_abort("This should not happen since timeout is forever\n");
332 }
333 if (rmMsg == NULL) {
334 System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
335 }
337 /* Extract the Rm_Packet from the RM msg */
338 rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
339 beginMemAccess((void *) rmPkt, rmPkt->pktLenBytes);
341 /* Provide packet to RM for processing */
342 if (status = Rm_receivePacket(rmTransportMap[transportMapEntry].transportHandle, rmPkt)) {
343 System_printf("Core %d: RM encountered error processing received packet: %d\n", MultiProc_self(), status);
344 }
346 /* Free RM packet buffer and messageQ message */
347 transportFree(rmMsg, rmPkt);
348 }
349 }
351 /*
352 * ======== testServiceCallback ========
353 * Application's callback function given to RM on service requests
354 */
355 void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
356 {
357 if (serviceResponse->serviceId == waitForBlockingOperation) {
358 waitForBlockingOperation = 0;
359 strcpy(responseInfo.resourceName, serviceResponse->resourceName);
360 responseInfo.resourceBase = serviceResponse->resourceBase;
361 responseInfo.resourceLength = serviceResponse->resourceLength;
362 responseInfo.serviceState = serviceResponse->serviceState;
363 }
364 else {
365 System_printf("Core %d: validation of static request with ID %d\n", MultiProc_self(),
366 serviceResponse->serviceId);
367 System_printf(" resource: %s, state: %d, base: %d, length: %d\n", serviceResponse->resourceName,
368 serviceResponse->serviceState,
369 serviceResponse->resourceBase,
370 serviceResponse->resourceLength);
371 }
372 }
374 bool blockForResponse(Rm_ServiceRespInfo *respInfo)
375 {
376 waitForBlockingOperation = respInfo->serviceId;
377 /* Block and wait for the response if the RM needed to perform a blocking operation
378 * to complete the request */
379 while(waitForBlockingOperation) {
380 /* Yield to receive task to see if there are any packets for RM instance */
381 Task_yield();
382 }
384 if ((respInfo->serviceState != RM_SERVICE_PROCESSING) &&
385 (respInfo->serviceState != RM_SERVICE_APPROVED) &&
386 (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) {
387 System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(),
388 respInfo->serviceState);
389 return(FALSE);
390 }
391 return(TRUE);
392 }
394 /*
395 * ======== testRmTsk ========
396 * RM cleanup task
397 */
398 void cleanupRmTsk(UArg arg0, UArg arg1)
399 {
400 /* Delete the RM test task */
401 System_printf("Core %d: Deleting RM test task...\n", MultiProc_self());
402 if (testRmTskHandle) {
403 Task_delete(&testRmTskHandle);
404 /* Set the task handle to be NULL so that the delete only occurs once */
405 testRmTskHandle = NULL;
406 }
407 /* Delete the RM receive task */
408 System_printf("Core %d: Deleting RM receive task...\n", MultiProc_self());
409 if (testReceiveTskHandle) {
410 Task_delete(&testReceiveTskHandle);
411 /* Set the task handle to be NULL so that the delete only occurs once */
412 testReceiveTskHandle = NULL;
413 }
415 /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
417 BIOS_exit(0);
418 }
420 /*
421 * ======== testRmTsk ========
422 * RM test task
423 */
424 void testReceiveTsk(UArg arg0, UArg arg1)
425 {
426 while(1) {
427 if (MultiProc_self() == 0) {
428 transportReceive(SERVER_TO_CD_MAP_ENTRY);
429 }
430 else if (MultiProc_self() == 1) {
431 transportReceive(CD_TO_SERVER_MAP_ENTRY);
432 transportReceive(CD_TO_CLIENT_MAP_ENTRY);
433 transportReceive(CLIENT_TO_CD_MAP_ENTRY);
434 }
435 /* Yield for main test task */
436 Task_yield();
437 }
438 }
440 /*
441 * ======== testRmTsk ========
442 * RM test task
443 */
444 void testRmTsk(UArg arg0, UArg arg1)
445 {
446 Rm_ServiceReqInfo requestInfo;
447 Task_Params taskParams;
448 int32_t result;
450 /* Delete the RM startup task */
451 System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
452 if (startupRmTskHandle) {
453 Task_delete(&startupRmTskHandle);
454 /* Set the task handle to be NULL so that the delete only occurs once */
455 startupRmTskHandle = NULL;
456 }
458 /* Open service ports on all the RM instances to test service requests from the different
459 * RM instances */
460 if (MultiProc_self() == 0) {
461 rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
463 Rm_printInstanceStatus(rmServerHandle);
464 }
465 else if (MultiProc_self() == 1) {
466 /* CD and Client serviceHandles were allocated in main() for static allocations.
467 * just reuse */
469 Rm_printInstanceStatus(rmClientDelegateHandle);
470 Rm_printInstanceStatus(rmClientHandle);
471 }
473 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
474 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
476 System_printf("Core %d: Testing NameServer features...\n", MultiProc_self());
478 /* Use the service ports to test the service requests */
479 if (MultiProc_self() == 0) {
480 /* Issue the service request create a new NameServer object via the service port */
481 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
482 requestInfo.resourceName = resourceNameGpQ;
483 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
484 requestInfo.resourceLength = 1;
485 requestInfo.resourceAlignment = 0;
486 requestInfo.callback.serviceCallback = testServiceCallback;
488 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
489 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
490 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
491 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
492 if (blockForResponse(&responseInfo)) {
493 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
494 rmServerName,
495 responseInfo.resourceName,
496 responseInfo.resourceBase,
497 responseInfo.resourceLength);
498 }
499 }
500 else {
501 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
502 responseInfo.serviceState);
503 }
505 /* Issue the service request create a new NameServer object via the service port */
506 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
507 requestInfo.resourceName = resourceNameGpQ;
508 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
509 requestInfo.resourceLength = 1;
510 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
511 requestInfo.callback.serviceCallback = testServiceCallback;
513 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
514 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
515 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
516 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
517 if (blockForResponse(&responseInfo)) {
518 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
519 rmServerName,
520 responseInfo.resourceName,
521 responseInfo.resourceBase,
522 responseInfo.resourceLength);
523 }
524 }
525 else {
526 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
527 responseInfo.serviceState);
528 }
530 /* Issue the service request create a new NameServer object via the service port */
531 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
532 requestInfo.resourceName = resourceNameGpQ;
533 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
534 requestInfo.resourceLength = 1;
535 requestInfo.resourceAlignment = 200;
536 requestInfo.callback.serviceCallback = testServiceCallback;
538 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
539 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
540 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
541 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
542 if (blockForResponse(&responseInfo)) {
543 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
544 rmServerName,
545 responseInfo.resourceName,
546 responseInfo.resourceBase,
547 responseInfo.resourceLength);
548 }
549 }
550 else {
551 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
552 responseInfo.serviceState);
553 }
555 Rm_printResourceStatus(rmServerHandle);
558 /* Issue the service request create a new NameServer object via the service port */
559 requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
560 requestInfo.resourceName = resourceNameGpQ;
561 requestInfo.resourceBase = 1002;
562 requestInfo.resourceLength = 1;
563 requestInfo.resourceNsName = nameServerNameFavQ;
564 requestInfo.callback.serviceCallback = testServiceCallback;
566 System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName);
567 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
568 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
569 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
570 if (blockForResponse(&responseInfo)) {
571 System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
572 rmServerName,
573 nameServerNameFavQ,
574 requestInfo.resourceBase,
575 requestInfo.resourceLength);
576 }
577 }
578 else {
579 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
580 responseInfo.serviceState);
581 }
583 /* Wait for Client Delegate and Client to retrieve resource via the name and allocate it */
584 waitOnSyncObj();
586 Rm_printResourceStatus(rmServerHandle);
588 /* Wait for Client to free resource via the NameServer and delete the NameServer object. */
589 waitOnSyncObj();
591 Rm_printResourceStatus(rmServerHandle);
593 /* Try to allocate the memory region taken by the Linux Kernel */
594 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
595 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
596 requestInfo.resourceName = resourceNameMemRegion;
597 requestInfo.resourceBase = 12;
598 requestInfo.resourceLength = 1;
599 requestInfo.callback.serviceCallback = testServiceCallback;
601 System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName);
602 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
603 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
604 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
605 if (blockForResponse(&responseInfo)) {
606 System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
607 rmServerName,
608 requestInfo.resourceName,
609 requestInfo.resourceBase,
610 requestInfo.resourceLength);
611 }
612 }
613 else {
614 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
615 responseInfo.serviceState);
616 }
618 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
619 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
620 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
621 requestInfo.resourceName = resourceNameAifRxCh;
622 requestInfo.resourceBase = 14;
623 requestInfo.resourceLength = 5;
624 requestInfo.callback.serviceCallback = testServiceCallback;
626 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
627 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
628 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
629 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
630 if (blockForResponse(&responseInfo)) {
631 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
632 rmServerName,
633 requestInfo.resourceName,
634 requestInfo.resourceBase,
635 requestInfo.resourceLength);
636 }
637 }
638 else {
639 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
640 responseInfo.serviceState);
641 }
642 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
643 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
644 requestInfo.resourceName = resourceNameAifRxCh;
645 requestInfo.resourceBase = 19;
646 requestInfo.resourceLength = 31;
647 requestInfo.callback.serviceCallback = testServiceCallback;
649 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
650 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
651 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
652 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
653 if (blockForResponse(&responseInfo)) {
654 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
655 rmServerName,
656 requestInfo.resourceName,
657 requestInfo.resourceBase,
658 requestInfo.resourceLength);
659 }
660 }
661 else {
662 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
663 responseInfo.serviceState);
664 }
666 /* Wait for Client and Client Delegate to do their allocates */
667 waitOnSyncObj();
669 Rm_printResourceStatus(rmServerHandle);
671 /* Free resources to show tree handling of different frees */
672 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
673 requestInfo.type = Rm_service_RESOURCE_FREE;
674 requestInfo.resourceName = resourceNameAifRxCh;
675 requestInfo.resourceBase = 25;
676 requestInfo.resourceLength = 3;
677 requestInfo.callback.serviceCallback = testServiceCallback;
679 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
680 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
681 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
682 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
683 if (blockForResponse(&responseInfo)) {
684 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
685 rmServerName,
686 requestInfo.resourceName,
687 requestInfo.resourceBase,
688 requestInfo.resourceLength);
689 }
690 }
691 else {
692 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
693 responseInfo.serviceState);
694 }
696 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
697 requestInfo.type = Rm_service_RESOURCE_FREE;
698 requestInfo.resourceName = resourceNameAifRxCh;
699 requestInfo.resourceBase = 34;
700 requestInfo.resourceLength = 3;
701 requestInfo.callback.serviceCallback = testServiceCallback;
703 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
704 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
705 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
706 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
707 if (blockForResponse(&responseInfo)) {
708 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
709 rmServerName,
710 requestInfo.resourceName,
711 requestInfo.resourceBase,
712 requestInfo.resourceLength);
713 }
714 }
715 else {
716 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
717 responseInfo.serviceState);
718 }
720 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
721 requestInfo.type = Rm_service_RESOURCE_FREE;
722 requestInfo.resourceName = resourceNameAifRxCh;
723 requestInfo.resourceBase = 28;
724 requestInfo.resourceLength = 6;
725 requestInfo.callback.serviceCallback = testServiceCallback;
727 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
728 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
729 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
730 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
731 if (blockForResponse(&responseInfo)) {
732 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
733 rmServerName,
734 requestInfo.resourceName,
735 requestInfo.resourceBase,
736 requestInfo.resourceLength);
737 }
738 }
739 else {
740 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
741 responseInfo.serviceState);
742 }
744 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
745 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
746 requestInfo.resourceName = resourceNameAifRxCh;
747 requestInfo.resourceBase = 53;
748 requestInfo.resourceLength = 2;
749 requestInfo.callback.serviceCallback = testServiceCallback;
751 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
752 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
753 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
754 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
755 if (blockForResponse(&responseInfo)) {
756 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
757 rmServerName,
758 requestInfo.resourceName,
759 requestInfo.resourceBase,
760 requestInfo.resourceLength);
761 }
762 }
763 else {
764 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
765 responseInfo.serviceState);
766 }
767 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
768 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
769 requestInfo.resourceName = resourceNameAifRxCh;
770 requestInfo.resourceBase = 2;
771 requestInfo.resourceLength = 2;
772 requestInfo.callback.serviceCallback = testServiceCallback;
774 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
775 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
776 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
777 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
778 if (blockForResponse(&responseInfo)) {
779 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
780 rmServerName,
781 requestInfo.resourceName,
782 requestInfo.resourceBase,
783 requestInfo.resourceLength);
784 }
785 }
786 else {
787 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
788 responseInfo.serviceState);
789 }
791 Rm_printResourceStatus(rmServerHandle);
793 /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
794 waitOnSyncObj();
796 Rm_printResourceStatus(rmServerHandle);
798 /* Test allocation of a resource twice from the same instance with init and use privileges. Both
799 * should be approved but the instance should only be mentioned once in the resource's owner list */
800 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
801 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
802 requestInfo.resourceName = resourceNameGpQ;
803 requestInfo.resourceBase = 6543;
804 requestInfo.resourceLength = 10;
805 requestInfo.callback.serviceCallback = testServiceCallback;
807 System_printf("Core %d: %s Allocating resource for init...\n", MultiProc_self(), rmServerName);
808 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
809 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
810 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
811 if (blockForResponse(&responseInfo)) {
812 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
813 rmServerName,
814 requestInfo.resourceName,
815 requestInfo.resourceBase,
816 requestInfo.resourceLength);
817 }
818 }
819 else {
820 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
821 responseInfo.serviceState);
822 }
823 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
824 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
825 requestInfo.resourceName = resourceNameGpQ;
826 requestInfo.resourceBase = 6543;
827 requestInfo.resourceLength = 10;
828 requestInfo.callback.serviceCallback = testServiceCallback;
830 System_printf("Core %d: %s Allocating same resource for use...\n", MultiProc_self(), rmServerName);
831 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
832 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
833 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
834 if (blockForResponse(&responseInfo)) {
835 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
836 rmServerName,
837 requestInfo.resourceName,
838 requestInfo.resourceBase,
839 requestInfo.resourceLength);
840 }
841 }
842 else {
843 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
844 responseInfo.serviceState);
845 }
847 Rm_printResourceStatus(rmServerHandle);
849 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
850 * Rm_Client */
851 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
852 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
853 requestInfo.resourceName = resourceNameInfraQ;
854 requestInfo.resourceBase = 805;
855 requestInfo.resourceLength = 1;
856 requestInfo.callback.serviceCallback = testServiceCallback;
858 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmServerName);
859 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
860 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
861 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
862 if (blockForResponse(&responseInfo)) {
863 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
864 rmServerName,
865 requestInfo.resourceName,
866 requestInfo.resourceBase,
867 requestInfo.resourceLength);
868 }
869 }
870 else {
871 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
872 responseInfo.serviceState);
873 }
875 Rm_printResourceStatus(rmServerHandle);
876 }
877 else if (MultiProc_self() == 1) {
878 /* Issue the service request for the resources tied to the name via the service port */
879 requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME;
880 requestInfo.resourceNsName = nameServerNameFavQ;
881 requestInfo.callback.serviceCallback = testServiceCallback;
883 System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
884 rmClientDelegateName);
885 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
886 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
887 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
888 if (blockForResponse(&responseInfo)) {
889 System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
890 rmClientDelegateName,
891 nameServerNameFavQ,
892 responseInfo.resourceBase,
893 responseInfo.resourceLength);
894 }
895 }
896 else {
897 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
898 responseInfo.serviceState);
899 }
901 /* Allocate the resources via the service port from the Client */
902 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
903 requestInfo.resourceName = responseInfo.resourceName;
904 requestInfo.resourceBase = responseInfo.resourceBase;
905 requestInfo.resourceLength = responseInfo.resourceLength;
906 requestInfo.resourceNsName = NULL;
907 requestInfo.callback.serviceCallback = testServiceCallback;
909 System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
910 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
911 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
912 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
913 if (blockForResponse(&responseInfo)) {
914 System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
915 rmClientName,
916 nameServerNameFavQ,
917 responseInfo.resourceBase,
918 responseInfo.resourceLength);
919 }
920 }
921 else {
922 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
923 responseInfo.serviceState);
924 }
926 /* Release the syncObj so Server can print results of NameServer object add and resource allocate */
927 releaseSyncObj();
929 /* Take the syncObj to free the name resource via the name, rather than the base+length */
930 takeSyncObj();
932 /* Free the named resource using the name via the service port from the Client */
933 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
934 requestInfo.type = Rm_service_RESOURCE_FREE;
935 requestInfo.resourceNsName = nameServerNameFavQ;
936 requestInfo.callback.serviceCallback = testServiceCallback;
938 System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
939 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
940 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
941 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
942 if (blockForResponse(&responseInfo)) {
943 System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
944 rmClientName,
945 nameServerNameFavQ);
946 }
947 }
948 else {
949 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
950 responseInfo.serviceState);
951 }
953 /* Delete the name object from the NameServer */
954 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
955 requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME;
956 requestInfo.resourceNsName = nameServerNameFavQ;
957 requestInfo.callback.serviceCallback = testServiceCallback;
959 System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
960 rmClientName,
961 nameServerNameFavQ);
962 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
963 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
964 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
965 if (blockForResponse(&responseInfo)) {
966 System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
967 rmClientName,
968 nameServerNameFavQ);
969 }
970 }
971 else {
972 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
973 responseInfo.serviceState);
974 }
976 /* Release the syncObj so Server can print results of resource free and NameServer object delete. */
977 releaseSyncObj();
979 /* Take the syncObj to allocate resources for testing resource tree interactions. */
980 takeSyncObj();
982 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
983 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
984 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
985 requestInfo.resourceName = resourceNameAifRxCh;
986 requestInfo.resourceBase = 0;
987 requestInfo.resourceLength = 6;
988 requestInfo.callback.serviceCallback = testServiceCallback;
990 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
991 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
992 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
993 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
994 if (blockForResponse(&responseInfo)) {
995 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
996 rmClientName,
997 requestInfo.resourceName,
998 requestInfo.resourceBase,
999 requestInfo.resourceLength);
1000 }
1001 }
1002 else {
1003 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1004 responseInfo.serviceState);
1005 }
1007 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1008 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1009 requestInfo.resourceName = resourceNameAifRxCh;
1010 requestInfo.resourceBase = 50;
1011 requestInfo.resourceLength = 7;
1012 requestInfo.callback.serviceCallback = testServiceCallback;
1014 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
1015 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1016 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1017 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1018 if (blockForResponse(&responseInfo)) {
1019 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1020 rmClientDelegateName,
1021 requestInfo.resourceName,
1022 requestInfo.resourceBase,
1023 requestInfo.resourceLength);
1024 }
1025 }
1026 else {
1027 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1028 responseInfo.serviceState);
1029 }
1031 /* Release the syncObj so Server can print results of resource allocations */
1032 releaseSyncObj();
1034 /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */
1035 takeSyncObj();
1037 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1038 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1039 requestInfo.resourceName = resourceNameAccumCh;
1040 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1041 requestInfo.resourceLength = 5;
1042 requestInfo.resourceAlignment = 4;
1043 requestInfo.callback.serviceCallback = testServiceCallback;
1045 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
1046 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1047 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1048 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1049 if (blockForResponse(&responseInfo)) {
1050 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1051 rmClientDelegateName,
1052 responseInfo.resourceName,
1053 responseInfo.resourceBase,
1054 responseInfo.resourceLength);
1055 }
1056 }
1057 else {
1058 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1059 responseInfo.serviceState);
1060 }
1062 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1063 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1064 requestInfo.resourceName = resourceNameAccumCh;
1065 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1066 requestInfo.resourceLength = 2;
1067 requestInfo.resourceAlignment = 1;
1068 requestInfo.callback.serviceCallback = testServiceCallback;
1070 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1071 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1072 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1073 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1074 if (blockForResponse(&responseInfo)) {
1075 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1076 rmClientName,
1077 responseInfo.resourceName,
1078 responseInfo.resourceBase,
1079 responseInfo.resourceLength);
1080 }
1081 }
1082 else {
1083 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1084 responseInfo.serviceState);
1085 }
1087 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1088 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1089 requestInfo.resourceName = resourceNameAccumCh;
1090 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1091 requestInfo.resourceLength = 2;
1092 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
1093 requestInfo.callback.serviceCallback = testServiceCallback;
1095 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1096 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1097 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1098 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1099 if (blockForResponse(&responseInfo)) {
1100 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1101 rmClientName,
1102 responseInfo.resourceName,
1103 responseInfo.resourceBase,
1104 responseInfo.resourceLength);
1105 }
1106 }
1107 else {
1108 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1109 responseInfo.serviceState);
1110 }
1112 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
1113 * Rm_Client */
1114 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1115 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1116 requestInfo.resourceName = resourceNameInfraQ;
1117 requestInfo.resourceBase = 800;
1118 requestInfo.resourceLength = 1;
1119 requestInfo.callback.serviceCallback = testServiceCallback;
1121 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmClientName);
1122 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1123 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1124 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1125 if (blockForResponse(&responseInfo)) {
1126 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
1127 rmClientName,
1128 requestInfo.resourceName,
1129 requestInfo.resourceBase,
1130 requestInfo.resourceLength);
1131 }
1132 }
1133 else {
1134 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1135 responseInfo.serviceState);
1136 }
1138 /* Release the syncObj so Server can print results of resource allocations */
1139 releaseSyncObj();
1140 }
1142 System_printf("Core %d: Testing is complete\n", MultiProc_self());
1144 /* Create the RM cleanup task. */
1145 System_printf("Core %d: Creating RM cleanup task...\n", MultiProc_self());
1146 Task_Params_init (&taskParams);
1147 Task_create (cleanupRmTsk, &taskParams, NULL);
1148 }
1150 /*
1151 * ======== startupRmTsk ========
1152 * Configures application transports and registers them with RM
1153 */
1154 Void startupRmTsk(UArg arg0, UArg arg1)
1155 {
1156 MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
1157 MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
1158 Int status, i;
1159 HeapBufMP_Handle msgQHeapHandle;
1160 HeapBufMP_Params heapBufParams;
1161 Rm_TransportCfg rmTransportCfg;
1162 int32_t result = 0;
1163 Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
1164 Task_Params taskParams;
1166 if (MultiProc_self() == 1) {
1167 /* Take the syncObj on core 1, preparing for RM testing */
1168 takeSyncObj();
1169 }
1171 /* Initialize the transport map */
1172 for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
1173 rmTransportMap[i].transportHandle = NULL;
1174 }
1176 if (MultiProc_self() == 0) {
1177 /* Create the heap that will be used to allocate RM messages. This
1178 * heap is a multi-processor heap. It will be shared amongst
1179 * all RM instances. */
1180 HeapBufMP_Params_init(&heapBufParams);
1181 heapBufParams.regionId = 0;
1182 heapBufParams.name = RM_PKT_HEAP_NAME;
1183 heapBufParams.numBlocks = 64;
1184 heapBufParams.blockSize = sizeof(Rm_Packet);
1185 rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
1186 if (rmPktHeapHandle == NULL) {
1187 System_abort("HeapBufMP_create failed for RM packet heap\n" );
1188 }
1189 System_printf("Core %d: RM packet heap created\n", MultiProc_self());
1191 /* Create the heap that will be used to allocate messageQ messages. */
1192 HeapBufMP_Params_init(&heapBufParams);
1193 heapBufParams.regionId = 0;
1194 heapBufParams.name = MSGQ_HEAP_NAME;
1195 heapBufParams.numBlocks = 64;
1196 heapBufParams.blockSize = sizeof(MsgQ_RmPacket);
1197 msgQHeapHandle = HeapBufMP_create(&heapBufParams);
1198 if (msgQHeapHandle == NULL) {
1199 System_abort("HeapBufMP_create failed MessageQ message heap\n" );
1200 }
1201 System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
1202 }
1203 else {
1204 /* Open the heaps created by the other processor. Loop until opened. */
1205 do {
1206 status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
1207 /*
1208 * Sleep for 1 clock tick to avoid inundating remote processor
1209 * with interrupts if open failed
1210 */
1211 if (status < 0) {
1212 Task_sleep(1);
1213 }
1214 } while (status < 0);
1215 System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
1217 do {
1218 status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
1219 /*
1220 * Sleep for 1 clock tick to avoid inundating remote processor
1221 * with interrupts if open failed
1222 */
1223 if (status < 0) {
1224 Task_sleep(1);
1225 }
1226 } while (status < 0);
1227 System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
1228 }
1230 /* Register the MessageQ heap with MessageQ */
1231 MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
1233 /* Create the messageQ's for each RM instance connection
1234 * Need four queues. Topology will be:
1235 * RM Server <---> RM Client Delegate <---> RM Client
1236 * 1 queues on RM Server
1237 * 2 queues on RM Client Delegate
1238 * 1 queues on RM Client */
1239 if (MultiProc_self() == 0) {
1240 serverFromCdMsgQ = MessageQ_create(serverFromCdQueueName, NULL);
1241 if (serverFromCdMsgQ == NULL) {
1242 System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
1243 }
1244 System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1245 }
1246 else if (MultiProc_self() == 1) {
1247 cdFromServerMsgQ = MessageQ_create(cdFromServerQueueName, NULL);
1248 if (cdFromServerMsgQ == NULL) {
1249 System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
1250 }
1251 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
1253 cdFromClientMsgQ = MessageQ_create(cdFromClientQueueName, NULL);
1254 if (cdFromClientMsgQ == NULL) {
1255 System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
1256 }
1257 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
1259 clientFromCdMsgQ = MessageQ_create(clientFromCdQueueName, NULL);
1260 if (clientFromCdMsgQ == NULL)
1261 {
1262 System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
1263 }
1264 System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1265 }
1267 /* Open the remote message queues. Also register the RM transports with each RM instance */
1268 if (MultiProc_self() == 0) {
1269 /* Open the Client Delegate messageQ from the Server */
1270 do {
1271 status = MessageQ_open(cdFromServerQueueName, &serverToCdQId);
1272 /*
1273 * Sleep for 1 clock tick to avoid inundating remote processor
1274 * with interrupts if open failed
1275 */
1276 if (status < 0) {
1277 Task_sleep(1);
1278 }
1279 } while (status < 0);
1280 System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
1282 /* Register the Client Delegate with the RM Server Instance */
1283 rmTransportCfg.rmHandle = rmServerHandle;
1284 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCdQId;
1285 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1286 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1287 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1288 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1289 serverCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1291 /* Store the mapping information in the transport map */
1292 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
1293 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ;
1294 System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
1295 }
1296 else if (MultiProc_self() == 1) {
1297 /* Open the Server messageQ from the Client Delegate */
1298 do {
1299 status = MessageQ_open(serverFromCdQueueName, &cdToServerQId);
1300 /*
1301 * Sleep for 1 clock tick to avoid inundating remote processor
1302 * with interrupts if open failed
1303 */
1304 if (status < 0) {
1305 Task_sleep(1);
1306 }
1307 } while (status < 0);
1308 System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
1310 /* Register the Server with the RM Client Delegate Instance */
1311 rmTransportCfg.rmHandle = rmClientDelegateHandle;
1312 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToServerQId;
1313 rmTransportCfg.remoteInstType = Rm_instType_SERVER;
1314 rmTransportCfg.remoteInstName = &rmServerName[0];
1315 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1316 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1317 cdServerHandle = Rm_transportRegister(&rmTransportCfg, &result);
1319 /* Store the mapping information in the transport map */
1320 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
1321 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ;
1322 System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
1324 /* Open the Client messageQ from the Client Delegate */
1325 do {
1326 status = MessageQ_open(clientFromCdQueueName, &cdToClientQId);
1327 /*
1328 * Sleep for 1 clock tick to avoid inundating remote processor
1329 * with interrupts if open failed
1330 */
1331 if (status < 0) {
1332 Task_sleep(1);
1333 }
1334 } while (status < 0);
1335 System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
1337 /* Register the Client with the RM Client Delegate Instance */
1338 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClientQId;
1339 rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
1340 rmTransportCfg.remoteInstName = &rmClientName[0];
1341 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1342 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1343 cdClientHandle = Rm_transportRegister(&rmTransportCfg, &result);
1345 /* Store the mapping information in the transport map */
1346 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
1347 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ;
1348 System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
1350 /* Open the Client Delegate messageQ from the Client */
1351 do {
1352 status = MessageQ_open(cdFromClientQueueName, &clientToCdQId);
1353 /*
1354 * Sleep for 1 clock tick to avoid inundating remote processor
1355 * with interrupts if open failed
1356 */
1357 if (status < 0) {
1358 Task_sleep(1);
1359 }
1360 } while (status < 0);
1361 System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
1363 /* Register the Client Delegate with the RM Client Instance */
1364 rmTransportCfg.rmHandle = rmClientHandle;
1365 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCdQId;
1366 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1367 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1368 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1369 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1370 clientCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1372 /* Store the mapping information in the transport map */
1373 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
1374 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ;
1375 System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
1376 }
1378 /* Create the RM receive task. */
1379 System_printf("Core %d: Creating RM receive task...\n", MultiProc_self());
1380 Task_Params_init (&taskParams);
1381 testReceiveTskHandle = Task_create (testReceiveTsk, &taskParams, NULL);
1384 /* Create the RM test task. */
1385 System_printf("Core %d: Creating RM test task...\n", MultiProc_self());
1386 Task_Params_init (&taskParams);
1387 testRmTskHandle = Task_create (testRmTsk, &taskParams, NULL);
1388 }
1390 /*
1391 * ======== main ========
1392 * Synchronizes all processors (in Ipc_start) and calls BIOS_start
1393 */
1394 Int main(Int argc, Char* argv[])
1395 {
1396 Rm_InitCfg rmInitCfg;
1397 Task_Params taskParams;
1398 FILE *globalResourceFp;
1399 FILE *linuxDtbFp;
1400 FILE *globalPolicyFp;
1401 FILE *staticPolicyFp;
1402 Int globalResourceFileSize;
1403 Int linuxDtbFileSize;
1404 Int globalPolicyFileSize;
1405 Int staticPolicyFileSize;
1406 void *globalResourceList = NULL;
1407 void *linuxDtb = NULL;
1408 void *globalPolicy = NULL;
1409 void *staticPolicy = NULL;
1410 Int status;
1411 Int readSize;
1412 Rm_ServiceReqInfo requestInfo;
1413 int32_t result;
1415 System_printf ("*********************************************************\n");
1416 System_printf ("********************** RM Testing ***********************\n");
1417 System_printf ("*********************************************************\n");
1419 System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1421 /* Initialize the RM instances - RM must be initialized before anything else in the system
1422 * Core 0: 1 RM Instance - RM Server
1423 * Core 1: 2 RM Instances - RM Client Delegate
1424 * RM Client
1425 */
1426 if (MultiProc_self()== 0) {
1427 initSyncObj();
1429 globalResourceFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\global-resources.dtb", "rb");
1430 linuxDtbFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\linux-evm.dtb", "rb");
1431 globalPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\server-policy.dtb", "rb");
1433 fseek(globalResourceFp, 0, SEEK_END);
1434 globalResourceFileSize = ftell(globalResourceFp);
1435 rewind(globalResourceFp);
1437 fseek(linuxDtbFp, 0, SEEK_END);
1438 linuxDtbFileSize = ftell(linuxDtbFp);
1439 rewind(linuxDtbFp);
1441 fseek(globalPolicyFp, 0, SEEK_END);
1442 globalPolicyFileSize = ftell(globalPolicyFp);
1443 rewind(globalPolicyFp);
1445 globalResourceList = Osal_rmMalloc(globalResourceFileSize);
1446 linuxDtb = Osal_rmMalloc(linuxDtbFileSize);
1447 globalPolicy = Osal_rmMalloc(globalPolicyFileSize);
1449 readSize = fread(globalResourceList, 1, globalResourceFileSize, globalResourceFp);
1450 System_printf("Read Size compared to file size: %d : %d\n", readSize, globalResourceFileSize);
1451 readSize = fread(linuxDtb, 1, linuxDtbFileSize, linuxDtbFp);
1452 System_printf("Read Size compared to file size: %d : %d\n", readSize, linuxDtbFileSize);
1453 readSize = fread(globalPolicy, 1, globalPolicyFileSize, globalPolicyFp);
1454 System_printf("Read Size compared to file size: %d : %d\n", readSize, globalPolicyFileSize);
1456 /* Create the Server instance */
1457 rmInitCfg.instName = &rmServerName[0];
1458 rmInitCfg.instType = Rm_instType_SERVER;
1459 rmInitCfg.instCfg.serverCfg.globalResourceList = globalResourceList;
1460 rmInitCfg.instCfg.serverCfg.linuxDtb = linuxDtb;
1461 rmInitCfg.instCfg.serverCfg.globalPolicy = globalPolicy;
1462 rmServerHandle = Rm_init(&rmInitCfg, &result);
1463 System_printf("Core %d: RM Server instance created. Result = %d\n", MultiProc_self(), result);
1465 Rm_printResourceStatus(rmServerHandle);
1466 }
1467 else if (MultiProc_self()== 1) {
1468 staticPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\static-policy.dtb", "rb");
1470 fseek(staticPolicyFp, 0, SEEK_END);
1471 staticPolicyFileSize = ftell(staticPolicyFp);
1472 rewind(staticPolicyFp);
1473 staticPolicy = Osal_rmMalloc(staticPolicyFileSize);
1474 readSize = fread(staticPolicy, 1, staticPolicyFileSize, staticPolicyFp);
1475 System_printf("Read Size compared to file size: %d : %d\n", readSize, staticPolicyFileSize);
1477 /* Create the RM Client Delegate instance */
1478 rmInitCfg.instName = &rmClientDelegateName[0];
1479 rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
1480 rmInitCfg.instCfg.cdCfg.staticPolicy = staticPolicy;
1481 rmClientDelegateHandle = Rm_init(&rmInitCfg, &result);
1482 System_printf("Core %d: RM Client Delegate instance created. Result = %d\n", MultiProc_self(), result);
1484 /* Create the RM Client instance */
1485 rmInitCfg.instName = &rmClientName[0];
1486 rmInitCfg.instType = Rm_instType_CLIENT;
1487 rmInitCfg.instCfg.clientCfg.staticPolicy = staticPolicy;
1488 rmClientHandle = Rm_init(&rmInitCfg, &result);
1489 System_printf("Core %d: RM Client instance created. Result = %d\n", MultiProc_self(), result);
1491 /* Open service handles on the CD and Client to test static allocations */
1492 rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result);
1493 rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
1495 /* Static allocations */
1496 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1497 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1498 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1499 requestInfo.resourceName = resourceNameQosCluster;
1500 requestInfo.resourceBase = 0;
1501 requestInfo.resourceLength = 1;
1502 requestInfo.callback.serviceCallback = testServiceCallback;
1504 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1505 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1506 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1507 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1508 rmClientDelegateName,
1509 resourceNameQosCluster,
1510 responseInfo.resourceBase,
1511 responseInfo.resourceLength);
1512 }
1513 else {
1514 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1515 responseInfo.serviceState);
1516 }
1518 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1519 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1520 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1521 requestInfo.resourceName = resourceNameQosCluster;
1522 requestInfo.resourceBase = 2;
1523 requestInfo.resourceLength = 1;
1524 requestInfo.callback.serviceCallback = testServiceCallback;
1526 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1527 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1528 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1529 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1530 rmClientName,
1531 resourceNameQosCluster,
1532 responseInfo.resourceBase,
1533 responseInfo.resourceLength);
1534 }
1535 else {
1536 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1537 responseInfo.serviceState);
1538 }
1540 /* Next request should return error */
1541 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1542 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1543 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1544 requestInfo.resourceName = resourceNameQosCluster;
1545 requestInfo.resourceBase = 1;
1546 requestInfo.resourceLength = 1;
1547 requestInfo.callback.serviceCallback = testServiceCallback;
1549 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1550 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1551 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1552 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1553 rmClientName,
1554 resourceNameQosCluster,
1555 responseInfo.resourceBase,
1556 responseInfo.resourceLength);
1557 }
1558 else {
1559 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1560 responseInfo.serviceState);
1561 }
1563 /* Allocated shared resource to both CD and Client using static policy */
1564 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1565 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1566 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1567 requestInfo.resourceName = resourceNameAifQ;
1568 requestInfo.resourceBase = 525;
1569 requestInfo.resourceLength = 1;
1570 requestInfo.callback.serviceCallback = testServiceCallback;
1572 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1573 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1574 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1575 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1576 rmClientDelegateName,
1577 resourceNameAifQ,
1578 responseInfo.resourceBase,
1579 responseInfo.resourceLength);
1580 }
1581 else {
1582 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1583 responseInfo.serviceState);
1584 }
1586 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1587 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1588 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1589 requestInfo.resourceName = resourceNameAifQ;
1590 requestInfo.resourceBase = 525;
1591 requestInfo.resourceLength = 1;
1592 requestInfo.callback.serviceCallback = testServiceCallback;
1594 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1595 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1596 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1597 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1598 rmClientName,
1599 resourceNameAifQ,
1600 responseInfo.resourceBase,
1601 responseInfo.resourceLength);
1602 }
1603 else {
1604 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1605 responseInfo.serviceState);
1606 }
1607 }
1609 System_printf("Core %d: Starting IPC...\n", MultiProc_self());
1610 status = Ipc_start();
1611 if (status < 0) {
1612 System_abort("Ipc_start failed\n");
1613 }
1615 /* Create the RM startup task */
1616 System_printf("Core %d: Creating RM startup task...\n", MultiProc_self());
1617 Task_Params_init (&taskParams);
1618 startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL);
1620 System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
1621 BIOS_start();
1623 return (0);
1624 }