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 rmStartupTskHandle;
73 Task_Handle rmReceiveTskHandle;
74 Task_Handle rmServerTskHandle;
75 Task_Handle rmClientTskHandle;
77 /* ======== Application Heaps ======== */
78 #define RM_PKT_HEAP_NAME "rmHeapBuf"
79 HeapBufMP_Handle rmPktHeapHandle = NULL;
81 #define MSGQ_HEAP_NAME "msgQHeapBuf"
82 #define MSGQ_HEAP_ID 0
84 /* ======== RM Instance Names ======== */
85 Char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server";
86 Char rmClientDelegateName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate";
87 Char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
89 /* ======== RM DTB Files ======== */
90 extern const char rmGrl[];
91 extern const char rmGlobalPolicy[];
92 extern const char rmStaticPolicy[];
93 extern const char rmLinuxDtb[];
95 /* ======== RM IPC MessageQ Names ======== */
96 Char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue";
97 Char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue";
98 Char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue";
99 Char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue";
101 /* ======== Test Resource & NameServer Names ======== */
102 Char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions";
103 char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch";
104 Char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue";
105 Char resourceNameAifQ[RM_NAME_MAX_CHARS] = "aif-queue";
106 Char resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster";
107 Char resourceNameAifRxCh[RM_NAME_MAX_CHARS] = "aif-rx-ch";
108 Char resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
110 Char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
112 /* ======== RM Instance Handles ======== */
113 Rm_Handle rmServerHandle = NULL;
114 Rm_Handle rmClientDelegateHandle = NULL;
115 Rm_Handle rmClientHandle = NULL;
117 /* ======== RM Instance Service Ports ======== */
118 Rm_ServiceHandle *rmServerServiceHandle = NULL;
119 Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL;
120 Rm_ServiceHandle *rmClientServiceHandle = NULL;
122 /* ======== RM Transport Packet Definition ======== */
123 typedef struct {
124 MessageQ_MsgHeader msgQHeader;
125 /* Pointer to packet provided by RM */
126 Rm_Packet *rmPkt;
127 } MsgQ_RmPacket;
129 /* ======== RM Transport Mapping Tables for Application ======== */
130 /* Core 0 Map Entry Indices */
131 #define SERVER_TO_CD_MAP_ENTRY 0
132 /* Core 1 Map Entry Indicies */
133 #define CD_TO_SERVER_MAP_ENTRY 0
134 #define CD_TO_CLIENT_MAP_ENTRY 1
135 #define CLIENT_TO_CD_MAP_ENTRY 2
137 /* Max map entries across all cores */
138 #define MAX_MAPPING_ENTRIES 3
140 typedef struct {
141 Rm_TransportHandle transportHandle;
142 MessageQ_Handle receiveMsgQ;
143 } Transport_MapEntry;
145 /* Core 1 will have three mapping entries
146 * Two map entries for the Client Delegate
147 * One map entry for the Client */
148 Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
150 uint32_t waitForBlockingOperation = 0;
151 Rm_ServiceRespInfo responseInfo;
153 /* ======== RM Application Sync APIs ======== */
155 typedef struct {
156 uint32_t sem;
157 uint32_t pad[31];
158 } syncObj;
160 #pragma DATA_SECTION (testSyncObj, ".syncObj");
161 #pragma DATA_ALIGN (testSyncObj, 16)
162 syncObj testSyncObj;
164 /**
165 * @b Description
166 * @n
167 * The function is used to indicate that a block of memory is
168 * about to be accessed. If the memory block is cached then this
169 * indicates that the application would need to ensure that the
170 * cache is updated with the data from the actual memory.
171 *
172 * @param[in] ptr
173 * Address of memory block
174 *
175 * @param[in] size
176 * Size of memory block
177 *
178 * @retval
179 * Not Applicable
180 */
181 void beginMemAccess (void *ptr, uint32_t size)
182 {
183 uint32_t key;
185 key = Hwi_disable();
187 /* Cleanup the prefetch buffer also. */
188 CSL_XMC_invalidatePrefetchBuffer();
189 /* Invalidate L1D cache and wait until operation is complete.
190 * Use this approach if L2 cache is not enabled */
191 CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT);
192 asm (" nop 4");
193 asm (" nop 4");
194 asm (" nop 4");
195 asm (" nop 4");
196 Hwi_restore(key);
197 }
199 /**
200 * @b Description
201 * @n
202 * The function is used to indicate that the block of memory has
203 * finished being accessed. If the memory block is cached then the
204 * application would need to ensure that the contents of the cache
205 * are updated immediately to the actual memory.
206 *
207 * @param[in] ptr
208 * Address of memory block
209 *
210 * @param[in] size
211 * Size of memory block
212 *
213 * @retval
214 * Not Applicable
215 */
216 void endMemAccess (void *ptr, uint32_t size)
217 {
218 uint32_t key;
220 key = Hwi_disable();
222 /* Writeback L1D cache and wait until operation is complete.
223 * Use this approach if L2 cache is not enabled */
224 CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT);
225 asm (" nop 4");
226 asm (" nop 4");
227 asm (" nop 4");
228 asm (" nop 4");
229 Hwi_restore(key);
230 }
233 void initSyncObj(void)
234 {
235 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
236 testSyncObj.sem = 0;
237 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
238 }
240 void takeSyncObj(void)
241 {
242 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
243 testSyncObj.sem = 1;
244 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
245 }
247 void waitOnSyncObj(void)
248 {
249 do {
250 /* Yield for other tasks */
251 Task_yield();
252 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
253 } while (testSyncObj.sem == 1);
254 }
256 void releaseSyncObj(void)
257 {
258 beginMemAccess((void *) &testSyncObj, sizeof(syncObj));
259 testSyncObj.sem = 0;
260 endMemAccess((void *) &testSyncObj, sizeof(syncObj));
261 }
263 /* ======== RM Application Transport APIs ======== */
265 Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
266 {
267 Rm_Packet *rmPkt = NULL;
268 MsgQ_RmPacket *rmMsg = NULL;
270 /* Allocate a messageQ message for containing the RM packet */
271 rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
272 if (rmMsg == NULL) {
273 System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self());
274 *pktHandle = NULL;
275 return(NULL);
276 }
277 else {
278 /* Create and attach RM packet to MessageQ message. All transports will allocate from the same heap */
279 rmPkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
280 rmPkt->pktLenBytes = pktSize;
281 endMemAccess((void *)rmPkt, rmPkt->pktLenBytes);
282 rmMsg->rmPkt = rmPkt;
283 *pktHandle = (Rm_PacketHandle)rmMsg;
284 }
285 return (rmPkt);
286 }
288 void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt)
289 {
290 uint32_t pktSize = pkt->pktLenBytes;
291 int32_t status;
293 /* All transports will free rmPkts to the same heap */
294 HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
296 status = MessageQ_free(rmMsgQMsg);
297 if (status < 0) {
298 System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", MultiProc_self());
299 }
300 }
302 int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
303 {
304 MessageQ_QueueId remoteQueueId = (MessageQ_QueueId)appTransport;
305 MsgQ_RmPacket *rmMsg = pktHandle;
306 int32_t status;
308 /* Write back data that was written by RM after alloc */
309 endMemAccess((void *)rmMsg->rmPkt, rmMsg->rmPkt->pktLenBytes);
311 /* Send the message to the remote side */
312 status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
313 if (status < 0) {
314 transportFree((MessageQ_Msg)rmMsg, rmMsg->rmPkt);
315 System_printf("Core %d: MessageQ_put had a failure/error in TransportSend: error: %d\n", MultiProc_self(),
316 status);
317 }
318 return (status);
319 }
321 void transportReceive (uint32_t transportMapEntry)
322 {
323 MessageQ_Handle receiveQ;
324 int32_t numPkts;
325 MessageQ_Msg rmMsg = NULL;
326 Rm_Packet *rmPkt = NULL;
327 int32_t status;
328 uint32_t i;
330 /* Check if any packets available */
331 receiveQ = rmTransportMap[transportMapEntry].receiveMsgQ;
332 numPkts = (int32_t) MessageQ_count(receiveQ);
334 /* Process all available packets */
335 for (i = 0; i < numPkts; i++) {
336 status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
337 if (status < 0) {
338 System_abort("This should not happen since timeout is forever\n");
339 }
340 if (rmMsg == NULL) {
341 System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
342 }
344 /* Extract the Rm_Packet from the RM msg */
345 rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
346 beginMemAccess((void *) rmPkt, rmPkt->pktLenBytes);
348 /* Provide packet to RM for processing */
349 if (status = Rm_receivePacket(rmTransportMap[transportMapEntry].transportHandle, rmPkt)) {
350 System_printf("Core %d: RM encountered error processing received packet: %d\n", MultiProc_self(), status);
351 }
353 /* Free RM packet buffer and messageQ message */
354 transportFree(rmMsg, rmPkt);
355 }
356 }
358 /*
359 * ======== testServiceCallback ========
360 * Application's callback function given to RM on service requests
361 */
362 void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
363 {
364 if (serviceResponse->serviceId == waitForBlockingOperation) {
365 waitForBlockingOperation = 0;
366 strcpy(responseInfo.resourceName, serviceResponse->resourceName);
367 responseInfo.resourceBase = serviceResponse->resourceBase;
368 responseInfo.resourceLength = serviceResponse->resourceLength;
369 responseInfo.serviceState = serviceResponse->serviceState;
370 }
371 else {
372 System_printf("Core %d: validation of static request with ID %d\n", MultiProc_self(),
373 serviceResponse->serviceId);
374 System_printf(" resource: %s, state: %d, base: %d, length: %d\n", serviceResponse->resourceName,
375 serviceResponse->serviceState,
376 serviceResponse->resourceBase,
377 serviceResponse->resourceLength);
378 }
379 }
381 bool blockForResponse(Rm_ServiceRespInfo *respInfo)
382 {
383 waitForBlockingOperation = respInfo->serviceId;
384 /* Block and wait for the response if the RM needed to perform a blocking operation
385 * to complete the request */
386 while(waitForBlockingOperation) {
387 /* Yield to receive task to see if there are any packets for RM instance */
388 Task_yield();
389 }
391 if ((respInfo->serviceState != RM_SERVICE_PROCESSING) &&
392 (respInfo->serviceState != RM_SERVICE_APPROVED) &&
393 (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) {
394 System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(),
395 respInfo->serviceState);
396 return(FALSE);
397 }
398 return(TRUE);
399 }
401 /*
402 * ======== testRmTsk ========
403 * RM cleanup task
404 */
405 void rmCleanupTsk(UArg arg0, UArg arg1)
406 {
407 int32_t result;
409 /* Delete the RM test tasks */
410 if (MultiProc_self() == 0) {
411 if (rmServerTskHandle) {
412 System_printf("Core %d: Deleting RM server task...\n", MultiProc_self());
413 Task_delete(&rmServerTskHandle);
414 /* Set the task handle to be NULL so that the delete only occurs once */
415 rmServerTskHandle = NULL;
416 }
417 }
418 else if (MultiProc_self() == 1) {
419 if (rmClientTskHandle) {
420 System_printf("Core %d: Deleting RM client task...\n", MultiProc_self());
421 Task_delete(&rmClientTskHandle);
422 /* Set the task handle to be NULL so that the delete only occurs once */
423 rmClientTskHandle = NULL;
424 }
425 }
427 /* Delete the RM receive task */
428 System_printf("Core %d: Deleting RM receive task...\n", MultiProc_self());
429 if (rmReceiveTskHandle) {
430 Task_delete(&rmReceiveTskHandle);
431 /* Set the task handle to be NULL so that the delete only occurs once */
432 rmReceiveTskHandle = NULL;
433 }
435 /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
436 if (MultiProc_self() == 0) {
437 Rm_serviceCloseHandle(rmServerServiceHandle);
439 Rm_transportUnregister(rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle);
441 result = Rm_delete(rmServerHandle, true);
442 if (result != RM_OK) {
443 System_printf("Core %d: RM server instance delete failed with error %d\n", MultiProc_self(), result);
444 }
445 }
446 else if (MultiProc_self() == 1) {
447 Rm_serviceCloseHandle(rmClientDelegateServiceHandle);
448 Rm_serviceCloseHandle(rmClientServiceHandle);
450 Rm_transportUnregister(rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle);
451 Rm_transportUnregister(rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle);
452 Rm_transportUnregister(rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle);
454 result = Rm_delete(rmClientDelegateHandle, true);
455 if (result != RM_OK) {
456 System_printf("Core %d: RM cd instance delete failed with error %d\n", MultiProc_self(), result);
457 }
458 result = Rm_delete(rmClientHandle, true);
459 if (result != RM_OK) {
460 System_printf("Core %d: RM client instance delete failed with error %d\n", MultiProc_self(), result);
461 }
462 }
464 BIOS_exit(0);
465 }
467 /*
468 * ======== testRmTsk ========
469 * RM test task
470 */
471 void rmReceiveTsk(UArg arg0, UArg arg1)
472 {
473 while(1) {
474 if (MultiProc_self() == 0) {
475 transportReceive(SERVER_TO_CD_MAP_ENTRY);
476 }
477 else if (MultiProc_self() == 1) {
478 transportReceive(CD_TO_SERVER_MAP_ENTRY);
479 transportReceive(CD_TO_CLIENT_MAP_ENTRY);
480 transportReceive(CLIENT_TO_CD_MAP_ENTRY);
481 }
482 /* Yield for main test task */
483 Task_yield();
484 }
485 }
487 /*
488 * ======== testRmServerTsk ========
489 * RM Server test task
490 */
491 void rmServerTsk(UArg arg0, UArg arg1)
492 {
493 Rm_ServiceReqInfo requestInfo;
494 Task_Params taskParams;
495 int32_t result;
497 /* Delete the RM startup task */
498 System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
499 if (rmStartupTskHandle) {
500 Task_delete(&rmStartupTskHandle);
501 /* Set the task handle to be NULL so that the delete only occurs once */
502 rmStartupTskHandle = NULL;
503 }
505 /* Open service ports on Server instance to test service requests from the different
506 * RM instances */
507 rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
509 Rm_printInstanceStatus(rmServerHandle);
511 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
512 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
514 /* Issue the service request create a new NameServer object via the service port */
515 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
516 requestInfo.resourceName = resourceNameGpQ;
517 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
518 requestInfo.resourceLength = 1;
519 requestInfo.resourceAlignment = 0;
521 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
522 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
523 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
524 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
525 if (blockForResponse(&responseInfo)) {
526 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
527 rmServerName,
528 responseInfo.resourceName,
529 responseInfo.resourceBase,
530 responseInfo.resourceLength);
531 }
532 }
533 else {
534 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
535 responseInfo.serviceState);
536 }
538 /* Issue the service request create a new NameServer object via the service port */
539 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
540 requestInfo.resourceName = resourceNameGpQ;
541 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
542 requestInfo.resourceLength = 1;
543 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
545 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
546 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
547 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
548 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
549 if (blockForResponse(&responseInfo)) {
550 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
551 rmServerName,
552 responseInfo.resourceName,
553 responseInfo.resourceBase,
554 responseInfo.resourceLength);
555 }
556 }
557 else {
558 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
559 responseInfo.serviceState);
560 }
562 /* Issue the service request create a new NameServer object via the service port */
563 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
564 requestInfo.resourceName = resourceNameGpQ;
565 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
566 requestInfo.resourceLength = 1;
567 requestInfo.resourceAlignment = 200;
569 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
570 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
571 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
572 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
573 if (blockForResponse(&responseInfo)) {
574 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
575 rmServerName,
576 responseInfo.resourceName,
577 responseInfo.resourceBase,
578 responseInfo.resourceLength);
579 }
580 }
581 else {
582 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
583 responseInfo.serviceState);
584 }
586 // Rm_printResourceStatus(rmServerHandle);
589 /* Issue the service request create a new NameServer object via the service port */
590 requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
591 requestInfo.resourceName = resourceNameGpQ;
592 requestInfo.resourceBase = 1002;
593 requestInfo.resourceLength = 1;
594 requestInfo.resourceNsName = nameServerNameFavQ;
596 System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName);
597 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
598 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
599 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
600 if (blockForResponse(&responseInfo)) {
601 System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(),
602 rmServerName,
603 nameServerNameFavQ,
604 requestInfo.resourceBase,
605 requestInfo.resourceLength);
606 }
607 }
608 else {
609 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
610 responseInfo.serviceState);
611 }
613 /* Wait for Client Delegate and Client to retrieve resource via the name and allocate it */
614 waitOnSyncObj();
616 // Rm_printResourceStatus(rmServerHandle);
618 /* Wait for Client to free resource via the NameServer and delete the NameServer object. */
619 waitOnSyncObj();
621 // Rm_printResourceStatus(rmServerHandle);
623 /* Try to allocate the memory region taken by the Linux Kernel */
624 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
625 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
626 requestInfo.resourceName = resourceNameMemRegion;
627 requestInfo.resourceBase = 12;
628 requestInfo.resourceLength = 1;
630 System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName);
631 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
632 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
633 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
634 if (blockForResponse(&responseInfo)) {
635 System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(),
636 rmServerName,
637 requestInfo.resourceName,
638 requestInfo.resourceBase,
639 requestInfo.resourceLength);
640 }
641 }
642 else {
643 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
644 responseInfo.serviceState);
645 }
647 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
648 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
649 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
650 requestInfo.resourceName = resourceNameAifRxCh;
651 requestInfo.resourceBase = 14;
652 requestInfo.resourceLength = 5;
654 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
655 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
656 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
657 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
658 if (blockForResponse(&responseInfo)) {
659 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
660 rmServerName,
661 requestInfo.resourceName,
662 requestInfo.resourceBase,
663 requestInfo.resourceLength);
664 }
665 }
666 else {
667 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
668 responseInfo.serviceState);
669 }
670 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
671 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
672 requestInfo.resourceName = resourceNameAifRxCh;
673 requestInfo.resourceBase = 19;
674 requestInfo.resourceLength = 31;
676 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName);
677 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
678 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
679 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
680 if (blockForResponse(&responseInfo)) {
681 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
682 rmServerName,
683 requestInfo.resourceName,
684 requestInfo.resourceBase,
685 requestInfo.resourceLength);
686 }
687 }
688 else {
689 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
690 responseInfo.serviceState);
691 }
693 /* Wait for Client and Client Delegate to do their allocates */
694 waitOnSyncObj();
696 // Rm_printResourceStatus(rmServerHandle);
698 /* Free resources to show tree handling of different frees */
699 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
700 requestInfo.type = Rm_service_RESOURCE_FREE;
701 requestInfo.resourceName = resourceNameAifRxCh;
702 requestInfo.resourceBase = 25;
703 requestInfo.resourceLength = 3;
705 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
706 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
707 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
708 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
709 if (blockForResponse(&responseInfo)) {
710 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
711 rmServerName,
712 requestInfo.resourceName,
713 requestInfo.resourceBase,
714 requestInfo.resourceLength);
715 }
716 }
717 else {
718 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
719 responseInfo.serviceState);
720 }
722 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
723 requestInfo.type = Rm_service_RESOURCE_FREE;
724 requestInfo.resourceName = resourceNameAifRxCh;
725 requestInfo.resourceBase = 34;
726 requestInfo.resourceLength = 3;
728 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
729 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
730 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
731 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
732 if (blockForResponse(&responseInfo)) {
733 System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(),
734 rmServerName,
735 requestInfo.resourceName,
736 requestInfo.resourceBase,
737 requestInfo.resourceLength);
738 }
739 }
740 else {
741 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
742 responseInfo.serviceState);
743 }
745 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
746 requestInfo.type = Rm_service_RESOURCE_FREE;
747 requestInfo.resourceName = resourceNameAifRxCh;
748 requestInfo.resourceBase = 28;
749 requestInfo.resourceLength = 6;
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 freed 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 }
768 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
769 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
770 requestInfo.resourceName = resourceNameAifRxCh;
771 requestInfo.resourceBase = 53;
772 requestInfo.resourceLength = 2;
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 }
790 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
791 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
792 requestInfo.resourceName = resourceNameAifRxCh;
793 requestInfo.resourceBase = 2;
794 requestInfo.resourceLength = 2;
796 System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName);
797 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
798 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
799 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
800 if (blockForResponse(&responseInfo)) {
801 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
802 rmServerName,
803 requestInfo.resourceName,
804 requestInfo.resourceBase,
805 requestInfo.resourceLength);
806 }
807 }
808 else {
809 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
810 responseInfo.serviceState);
811 }
813 // Rm_printResourceStatus(rmServerHandle);
815 /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
816 waitOnSyncObj();
818 // Rm_printResourceStatus(rmServerHandle);
820 /* Test allocation of a resource twice from the same instance with init and use privileges. Both
821 * should be approved but the instance should only be mentioned once in the resource's owner list */
822 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
823 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
824 requestInfo.resourceName = resourceNameGpQ;
825 requestInfo.resourceBase = 6543;
826 requestInfo.resourceLength = 10;
828 System_printf("Core %d: %s Allocating resource for init...\n", MultiProc_self(), rmServerName);
829 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
830 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
831 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
832 if (blockForResponse(&responseInfo)) {
833 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
834 rmServerName,
835 requestInfo.resourceName,
836 requestInfo.resourceBase,
837 requestInfo.resourceLength);
838 }
839 }
840 else {
841 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
842 responseInfo.serviceState);
843 }
844 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
845 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
846 requestInfo.resourceName = resourceNameGpQ;
847 requestInfo.resourceBase = 6543;
848 requestInfo.resourceLength = 10;
850 System_printf("Core %d: %s Allocating same resource for use...\n", MultiProc_self(), rmServerName);
851 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
852 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
853 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
854 if (blockForResponse(&responseInfo)) {
855 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
856 rmServerName,
857 requestInfo.resourceName,
858 requestInfo.resourceBase,
859 requestInfo.resourceLength);
860 }
861 }
862 else {
863 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
864 responseInfo.serviceState);
865 }
867 // Rm_printResourceStatus(rmServerHandle);
869 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
870 * Rm_Client */
871 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
872 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
873 requestInfo.resourceName = resourceNameInfraQ;
874 requestInfo.resourceBase = 805;
875 requestInfo.resourceLength = 1;
877 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmServerName);
878 rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
879 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
880 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
881 if (blockForResponse(&responseInfo)) {
882 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
883 rmServerName,
884 requestInfo.resourceName,
885 requestInfo.resourceBase,
886 requestInfo.resourceLength);
887 }
888 }
889 else {
890 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
891 responseInfo.serviceState);
892 }
894 Rm_printResourceStatus(rmServerHandle);
896 System_printf("Core %d: Testing is complete\n", MultiProc_self());
898 /* Create the RM cleanup task. */
899 System_printf("Core %d: Creating RM cleanup task...\n", MultiProc_self());
900 Task_Params_init (&taskParams);
901 Task_create (rmCleanupTsk, &taskParams, NULL);
902 }
904 /*
905 * ======== testRmClientTsk ========
906 * RM Client test task
907 */
908 void rmClientTsk(UArg arg0, UArg arg1)
909 {
910 Rm_ServiceReqInfo requestInfo;
911 Task_Params taskParams;
913 /* Delete the RM startup task */
914 System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self());
915 if (rmStartupTskHandle) {
916 Task_delete(&rmStartupTskHandle);
917 /* Set the task handle to be NULL so that the delete only occurs once */
918 rmStartupTskHandle = NULL;
919 }
921 /* CD and Client serviceHandles were allocated in main() for static allocations.
922 * just reuse */
923 Rm_printInstanceStatus(rmClientDelegateHandle);
924 Rm_printInstanceStatus(rmClientHandle);
926 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
927 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
929 /* Issue the service request for the resources tied to the name via the service port */
930 requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME;
931 requestInfo.resourceNsName = nameServerNameFavQ;
932 requestInfo.callback.serviceCallback = testServiceCallback;
934 System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(),
935 rmClientDelegateName);
936 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
937 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
938 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
939 if (blockForResponse(&responseInfo)) {
940 System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(),
941 rmClientDelegateName,
942 nameServerNameFavQ,
943 responseInfo.resourceBase,
944 responseInfo.resourceLength);
945 }
946 }
947 else {
948 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
949 responseInfo.serviceState);
950 }
952 /* Allocate the resources via the service port from the Client */
953 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
954 requestInfo.resourceName = responseInfo.resourceName;
955 requestInfo.resourceBase = responseInfo.resourceBase;
956 requestInfo.resourceLength = responseInfo.resourceLength;
957 requestInfo.resourceNsName = NULL;
958 requestInfo.callback.serviceCallback = testServiceCallback;
960 System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName);
961 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
962 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
963 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
964 if (blockForResponse(&responseInfo)) {
965 System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(),
966 rmClientName,
967 nameServerNameFavQ,
968 responseInfo.resourceBase,
969 responseInfo.resourceLength);
970 }
971 }
972 else {
973 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
974 responseInfo.serviceState);
975 }
977 /* Release the syncObj so Server can print results of NameServer object add and resource allocate */
978 releaseSyncObj();
980 /* Take the syncObj to free the name resource via the name, rather than the base+length */
981 takeSyncObj();
983 /* Free the named resource using the name via the service port from the Client */
984 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
985 requestInfo.type = Rm_service_RESOURCE_FREE;
986 requestInfo.resourceNsName = nameServerNameFavQ;
987 requestInfo.callback.serviceCallback = testServiceCallback;
989 System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName);
990 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
991 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
992 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
993 if (blockForResponse(&responseInfo)) {
994 System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(),
995 rmClientName,
996 nameServerNameFavQ);
997 }
998 }
999 else {
1000 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1001 responseInfo.serviceState);
1002 }
1004 /* Delete the name object from the NameServer */
1005 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1006 requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME;
1007 requestInfo.resourceNsName = nameServerNameFavQ;
1008 requestInfo.callback.serviceCallback = testServiceCallback;
1010 System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(),
1011 rmClientName,
1012 nameServerNameFavQ);
1013 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1014 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1015 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1016 if (blockForResponse(&responseInfo)) {
1017 System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(),
1018 rmClientName,
1019 nameServerNameFavQ);
1020 }
1021 }
1022 else {
1023 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1024 responseInfo.serviceState);
1025 }
1027 /* Release the syncObj so Server can print results of resource free and NameServer object delete. */
1028 releaseSyncObj();
1030 /* Take the syncObj to allocate resources for testing resource tree interactions. */
1031 takeSyncObj();
1033 /* Allocate some resources for testing tree interaction with multiple allocations from different instances */
1034 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1035 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1036 requestInfo.resourceName = resourceNameAifRxCh;
1037 requestInfo.resourceBase = 0;
1038 requestInfo.resourceLength = 6;
1039 requestInfo.callback.serviceCallback = testServiceCallback;
1041 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1042 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1043 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1044 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1045 if (blockForResponse(&responseInfo)) {
1046 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1047 rmClientName,
1048 requestInfo.resourceName,
1049 requestInfo.resourceBase,
1050 requestInfo.resourceLength);
1051 }
1052 }
1053 else {
1054 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1055 responseInfo.serviceState);
1056 }
1058 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1059 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1060 requestInfo.resourceName = resourceNameAifRxCh;
1061 requestInfo.resourceBase = 50;
1062 requestInfo.resourceLength = 7;
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 requestInfo.resourceName,
1073 requestInfo.resourceBase,
1074 requestInfo.resourceLength);
1075 }
1076 }
1077 else {
1078 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1079 responseInfo.serviceState);
1080 }
1082 /* Release the syncObj so Server can print results of resource allocations */
1083 releaseSyncObj();
1085 /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */
1086 takeSyncObj();
1088 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1089 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1090 requestInfo.resourceName = resourceNameAccumCh;
1091 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1092 requestInfo.resourceLength = 5;
1093 requestInfo.resourceAlignment = 4;
1094 requestInfo.callback.serviceCallback = testServiceCallback;
1096 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName);
1097 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1098 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1099 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1100 if (blockForResponse(&responseInfo)) {
1101 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1102 rmClientDelegateName,
1103 responseInfo.resourceName,
1104 responseInfo.resourceBase,
1105 responseInfo.resourceLength);
1106 }
1107 }
1108 else {
1109 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1110 responseInfo.serviceState);
1111 }
1113 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1114 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1115 requestInfo.resourceName = resourceNameAccumCh;
1116 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1117 requestInfo.resourceLength = 2;
1118 requestInfo.resourceAlignment = 1;
1119 requestInfo.callback.serviceCallback = testServiceCallback;
1121 System_printf("Core %d: %s Allocating resource...\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 allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1127 rmClientName,
1128 responseInfo.resourceName,
1129 responseInfo.resourceBase,
1130 responseInfo.resourceLength);
1131 }
1132 }
1133 else {
1134 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1135 responseInfo.serviceState);
1136 }
1138 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1139 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE;
1140 requestInfo.resourceName = resourceNameAccumCh;
1141 requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED;
1142 requestInfo.resourceLength = 2;
1143 requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED;
1144 requestInfo.callback.serviceCallback = testServiceCallback;
1146 System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName);
1147 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1148 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1149 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1150 if (blockForResponse(&responseInfo)) {
1151 System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(),
1152 rmClientName,
1153 responseInfo.resourceName,
1154 responseInfo.resourceBase,
1155 responseInfo.resourceLength);
1156 }
1157 }
1158 else {
1159 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1160 responseInfo.serviceState);
1161 }
1163 /* Attempt to allocate an infrastructure queue taken by the Linux kernel and shared with
1164 * Rm_Client */
1165 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1166 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1167 requestInfo.resourceName = resourceNameInfraQ;
1168 requestInfo.resourceBase = 800;
1169 requestInfo.resourceLength = 1;
1170 requestInfo.callback.serviceCallback = testServiceCallback;
1172 System_printf("Core %d: %s Attempting to allocate infrastructure queue taken by Linux...\n", MultiProc_self(), rmClientName);
1173 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1174 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1175 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1176 if (blockForResponse(&responseInfo)) {
1177 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
1178 rmClientName,
1179 requestInfo.resourceName,
1180 requestInfo.resourceBase,
1181 requestInfo.resourceLength);
1182 }
1183 }
1184 else {
1185 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1186 responseInfo.serviceState);
1187 }
1189 /* Attempt to request a service from an instance that requires a blocking operation to satisfy
1190 * the request without providing a callback function. */
1191 memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1192 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1193 requestInfo.resourceName = resourceNameGpQ;
1194 requestInfo.resourceBase = 7000;
1195 requestInfo.resourceLength = 1;
1197 System_printf("Core %d: %s Attempting service request without callback function...\n", MultiProc_self(), rmClientName);
1198 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1199 if ((responseInfo.serviceState == RM_SERVICE_APPROVED) ||
1200 (responseInfo.serviceState == RM_SERVICE_PROCESSING)) {
1201 if (blockForResponse(&responseInfo)) {
1202 System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(),
1203 rmClientName,
1204 requestInfo.resourceName,
1205 requestInfo.resourceBase,
1206 requestInfo.resourceLength);
1207 }
1208 }
1209 else {
1210 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1211 responseInfo.serviceState);
1212 }
1214 /* Release the syncObj so Server can print results of resource allocations */
1215 releaseSyncObj();
1217 System_printf("Core %d: Testing is complete\n", MultiProc_self());
1219 /* Create the RM cleanup task. */
1220 System_printf("Core %d: Creating RM cleanup task...\n", MultiProc_self());
1221 Task_Params_init (&taskParams);
1222 Task_create (rmCleanupTsk, &taskParams, NULL);
1223 }
1226 /*
1227 * ======== startupRmTsk ========
1228 * Configures application transports and registers them with RM
1229 */
1230 Void rmStartupTsk(UArg arg0, UArg arg1)
1231 {
1232 MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
1233 MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
1234 Int status, i;
1235 HeapBufMP_Handle msgQHeapHandle;
1236 HeapBufMP_Params heapBufParams;
1237 Rm_TransportCfg rmTransportCfg;
1238 int32_t result = 0;
1239 Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
1240 Task_Params taskParams;
1242 if (MultiProc_self() == 1) {
1243 /* Take the syncObj on core 1, preparing for RM testing */
1244 takeSyncObj();
1245 }
1247 /* Initialize the transport map */
1248 for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
1249 rmTransportMap[i].transportHandle = NULL;
1250 }
1252 if (MultiProc_self() == 0) {
1253 /* Create the heap that will be used to allocate RM messages. This
1254 * heap is a multi-processor heap. It will be shared amongst
1255 * all RM instances. */
1256 HeapBufMP_Params_init(&heapBufParams);
1257 heapBufParams.regionId = 0;
1258 heapBufParams.name = RM_PKT_HEAP_NAME;
1259 heapBufParams.numBlocks = 64;
1260 heapBufParams.blockSize = sizeof(Rm_Packet);
1261 rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
1262 if (rmPktHeapHandle == NULL) {
1263 System_abort("HeapBufMP_create failed for RM packet heap\n" );
1264 }
1265 System_printf("Core %d: RM packet heap created\n", MultiProc_self());
1267 /* Create the heap that will be used to allocate messageQ messages. */
1268 HeapBufMP_Params_init(&heapBufParams);
1269 heapBufParams.regionId = 0;
1270 heapBufParams.name = MSGQ_HEAP_NAME;
1271 heapBufParams.numBlocks = 64;
1272 heapBufParams.blockSize = sizeof(MsgQ_RmPacket);
1273 msgQHeapHandle = HeapBufMP_create(&heapBufParams);
1274 if (msgQHeapHandle == NULL) {
1275 System_abort("HeapBufMP_create failed MessageQ message heap\n" );
1276 }
1277 System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
1278 }
1279 else {
1280 /* Open the heaps created by the other processor. Loop until opened. */
1281 do {
1282 status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle);
1283 /*
1284 * Sleep for 1 clock tick to avoid inundating remote processor
1285 * with interrupts if open failed
1286 */
1287 if (status < 0) {
1288 Task_sleep(1);
1289 }
1290 } while (status < 0);
1291 System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
1293 do {
1294 status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle);
1295 /*
1296 * Sleep for 1 clock tick to avoid inundating remote processor
1297 * with interrupts if open failed
1298 */
1299 if (status < 0) {
1300 Task_sleep(1);
1301 }
1302 } while (status < 0);
1303 System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
1304 }
1306 /* Register the MessageQ heap with MessageQ */
1307 MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
1309 /* Create the messageQ's for each RM instance connection
1310 * Need four queues. Topology will be:
1311 * RM Server <---> RM Client Delegate <---> RM Client
1312 * 1 queues on RM Server
1313 * 2 queues on RM Client Delegate
1314 * 1 queues on RM Client */
1315 if (MultiProc_self() == 0) {
1316 serverFromCdMsgQ = MessageQ_create(serverFromCdQueueName, NULL);
1317 if (serverFromCdMsgQ == NULL) {
1318 System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" );
1319 }
1320 System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1321 }
1322 else if (MultiProc_self() == 1) {
1323 cdFromServerMsgQ = MessageQ_create(cdFromServerQueueName, NULL);
1324 if (cdFromServerMsgQ == NULL) {
1325 System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" );
1326 }
1327 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self());
1329 cdFromClientMsgQ = MessageQ_create(cdFromClientQueueName, NULL);
1330 if (cdFromClientMsgQ == NULL) {
1331 System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" );
1332 }
1333 System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self());
1335 clientFromCdMsgQ = MessageQ_create(clientFromCdQueueName, NULL);
1336 if (clientFromCdMsgQ == NULL)
1337 {
1338 System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" );
1339 }
1340 System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self());
1341 }
1343 /* Open the remote message queues. Also register the RM transports with each RM instance */
1344 if (MultiProc_self() == 0) {
1345 /* Open the Client Delegate messageQ from the Server */
1346 do {
1347 status = MessageQ_open(cdFromServerQueueName, &serverToCdQId);
1348 /*
1349 * Sleep for 1 clock tick to avoid inundating remote processor
1350 * with interrupts if open failed
1351 */
1352 if (status < 0) {
1353 Task_sleep(1);
1354 }
1355 } while (status < 0);
1356 System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
1358 /* Register the Client Delegate with the RM Server Instance */
1359 rmTransportCfg.rmHandle = rmServerHandle;
1360 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCdQId;
1361 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1362 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1363 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1364 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1365 serverCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1367 /* Store the mapping information in the transport map */
1368 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle;
1369 rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ;
1370 System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
1371 }
1372 else if (MultiProc_self() == 1) {
1373 /* Open the Server messageQ from the Client Delegate */
1374 do {
1375 status = MessageQ_open(serverFromCdQueueName, &cdToServerQId);
1376 /*
1377 * Sleep for 1 clock tick to avoid inundating remote processor
1378 * with interrupts if open failed
1379 */
1380 if (status < 0) {
1381 Task_sleep(1);
1382 }
1383 } while (status < 0);
1384 System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
1386 /* Register the Server with the RM Client Delegate Instance */
1387 rmTransportCfg.rmHandle = rmClientDelegateHandle;
1388 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToServerQId;
1389 rmTransportCfg.remoteInstType = Rm_instType_SERVER;
1390 rmTransportCfg.remoteInstName = &rmServerName[0];
1391 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1392 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1393 cdServerHandle = Rm_transportRegister(&rmTransportCfg, &result);
1395 /* Store the mapping information in the transport map */
1396 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle;
1397 rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ;
1398 System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
1400 /* Open the Client messageQ from the Client Delegate */
1401 do {
1402 status = MessageQ_open(clientFromCdQueueName, &cdToClientQId);
1403 /*
1404 * Sleep for 1 clock tick to avoid inundating remote processor
1405 * with interrupts if open failed
1406 */
1407 if (status < 0) {
1408 Task_sleep(1);
1409 }
1410 } while (status < 0);
1411 System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
1413 /* Register the Client with the RM Client Delegate Instance */
1414 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClientQId;
1415 rmTransportCfg.remoteInstType = Rm_instType_CLIENT;
1416 rmTransportCfg.remoteInstName = &rmClientName[0];
1417 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1418 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1419 cdClientHandle = Rm_transportRegister(&rmTransportCfg, &result);
1421 /* Store the mapping information in the transport map */
1422 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle;
1423 rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ;
1424 System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
1426 /* Open the Client Delegate messageQ from the Client */
1427 do {
1428 status = MessageQ_open(cdFromClientQueueName, &clientToCdQId);
1429 /*
1430 * Sleep for 1 clock tick to avoid inundating remote processor
1431 * with interrupts if open failed
1432 */
1433 if (status < 0) {
1434 Task_sleep(1);
1435 }
1436 } while (status < 0);
1437 System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
1439 /* Register the Client Delegate with the RM Client Instance */
1440 rmTransportCfg.rmHandle = rmClientHandle;
1441 rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCdQId;
1442 rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE;
1443 rmTransportCfg.remoteInstName = &rmClientDelegateName[0];
1444 rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
1445 rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
1446 clientCdHandle = Rm_transportRegister(&rmTransportCfg, &result);
1448 /* Store the mapping information in the transport map */
1449 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle;
1450 rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ;
1451 System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
1452 }
1454 /* Create the RM receive task. */
1455 System_printf("Core %d: Creating RM receive task...\n", MultiProc_self());
1456 Task_Params_init (&taskParams);
1457 rmReceiveTskHandle = Task_create (rmReceiveTsk, &taskParams, NULL);
1460 /* Create the RM test tasks. */
1461 if (MultiProc_self() == 0) {
1462 System_printf("Core %d: Creating RM server task...\n", MultiProc_self());
1463 Task_Params_init (&taskParams);
1464 rmServerTskHandle = Task_create (rmServerTsk, &taskParams, NULL);
1465 }
1466 else if (MultiProc_self()) {
1467 System_printf("Core %d: Creating RM client task...\n", MultiProc_self());
1468 Task_Params_init (&taskParams);
1469 rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
1470 }
1471 }
1473 /*
1474 * ======== main ========
1475 * Synchronizes all processors (in Ipc_start) and calls BIOS_start
1476 */
1477 Int main(Int argc, Char* argv[])
1478 {
1479 Rm_InitCfg rmInitCfg;
1480 Task_Params taskParams;
1481 Int status;
1482 Rm_ServiceReqInfo requestInfo;
1483 int32_t result;
1485 System_printf ("*********************************************************\n");
1486 System_printf ("********************** RM Testing ***********************\n");
1487 System_printf ("*********************************************************\n");
1489 System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
1491 /* Initialize the RM instances - RM must be initialized before anything else in the system
1492 * Core 0: 1 RM Instance - RM Server
1493 * Core 1: 2 RM Instances - RM Client Delegate
1494 * RM Client
1495 */
1496 if (MultiProc_self()== 0) {
1497 initSyncObj();
1499 /* Create the Server instance */
1500 rmInitCfg.instName = &rmServerName[0];
1501 rmInitCfg.instType = Rm_instType_SERVER;
1502 rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGrl;
1503 rmInitCfg.instCfg.serverCfg.linuxDtb = (void *)rmLinuxDtb;
1504 rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
1505 rmServerHandle = Rm_init(&rmInitCfg, &result);
1506 System_printf("Core %d: RM Server instance created. Result = %d\n", MultiProc_self(), result);
1508 Rm_printResourceStatus(rmServerHandle);
1509 }
1510 else if (MultiProc_self()== 1) {
1511 /* Create the RM Client Delegate instance */
1512 rmInitCfg.instName = &rmClientDelegateName[0];
1513 rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
1514 rmInitCfg.instCfg.cdCfg.staticPolicy = (void *)rmStaticPolicy;
1515 rmClientDelegateHandle = Rm_init(&rmInitCfg, &result);
1516 System_printf("Core %d: RM Client Delegate instance created. Result = %d\n", MultiProc_self(), result);
1518 /* Create the RM Client instance */
1519 rmInitCfg.instName = &rmClientName[0];
1520 rmInitCfg.instType = Rm_instType_CLIENT;
1521 rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
1522 rmClientHandle = Rm_init(&rmInitCfg, &result);
1523 System_printf("Core %d: RM Client instance created. Result = %d\n", MultiProc_self(), result);
1525 /* Open service handles on the CD and Client to test static allocations */
1526 rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result);
1527 rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
1529 /* Static allocations */
1530 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1531 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1532 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1533 requestInfo.resourceName = resourceNameQosCluster;
1534 requestInfo.resourceBase = 0;
1535 requestInfo.resourceLength = 1;
1536 requestInfo.callback.serviceCallback = testServiceCallback;
1538 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1539 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1540 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1541 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1542 rmClientDelegateName,
1543 resourceNameQosCluster,
1544 responseInfo.resourceBase,
1545 responseInfo.resourceLength);
1546 }
1547 else {
1548 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1549 responseInfo.serviceState);
1550 }
1552 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1553 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1554 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1555 requestInfo.resourceName = resourceNameQosCluster;
1556 requestInfo.resourceBase = 2;
1557 requestInfo.resourceLength = 1;
1558 requestInfo.callback.serviceCallback = testServiceCallback;
1560 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1561 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1562 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1563 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1564 rmClientName,
1565 resourceNameQosCluster,
1566 responseInfo.resourceBase,
1567 responseInfo.resourceLength);
1568 }
1569 else {
1570 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1571 responseInfo.serviceState);
1572 }
1574 /* Next request should return error */
1575 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1576 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1577 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1578 requestInfo.resourceName = resourceNameQosCluster;
1579 requestInfo.resourceBase = 1;
1580 requestInfo.resourceLength = 1;
1581 requestInfo.callback.serviceCallback = testServiceCallback;
1583 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1584 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1585 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1586 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1587 rmClientName,
1588 resourceNameQosCluster,
1589 responseInfo.resourceBase,
1590 responseInfo.resourceLength);
1591 }
1592 else {
1593 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1594 responseInfo.serviceState);
1595 }
1597 /* Allocated shared resource to both CD and Client using static policy */
1598 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1599 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1600 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1601 requestInfo.resourceName = resourceNameAifQ;
1602 requestInfo.resourceBase = 525;
1603 requestInfo.resourceLength = 1;
1604 requestInfo.callback.serviceCallback = testServiceCallback;
1606 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName);
1607 rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo);
1608 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1609 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1610 rmClientDelegateName,
1611 resourceNameAifQ,
1612 responseInfo.resourceBase,
1613 responseInfo.resourceLength);
1614 }
1615 else {
1616 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1617 responseInfo.serviceState);
1618 }
1620 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
1621 memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
1622 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
1623 requestInfo.resourceName = resourceNameAifQ;
1624 requestInfo.resourceBase = 525;
1625 requestInfo.resourceLength = 1;
1626 requestInfo.callback.serviceCallback = testServiceCallback;
1628 System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName);
1629 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
1630 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
1631 System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(),
1632 rmClientName,
1633 resourceNameAifQ,
1634 responseInfo.resourceBase,
1635 responseInfo.resourceLength);
1636 }
1637 else {
1638 System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(),
1639 responseInfo.serviceState);
1640 }
1641 }
1643 System_printf("Core %d: Starting IPC...\n", MultiProc_self());
1644 status = Ipc_start();
1645 if (status < 0) {
1646 System_abort("Ipc_start failed\n");
1647 }
1649 /* Create the RM startup task */
1650 System_printf("Core %d: Creating RM startup task...\n", MultiProc_self());
1651 Task_Params_init (&taskParams);
1652 rmStartupTskHandle = Task_create (rmStartupTsk, &taskParams, NULL);
1654 System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
1655 BIOS_start();
1657 return (0);
1658 }