b157830ff7f1f03b9e537e77aec3d820f0640616
1 /*
2 * dsp_client.c
3 *
4 * DSP portion of Resource Manager ARM+DSP test that uses RPMSG and sockets to
5 * allow a DSP application to to request RM services from a RM Server running
6 * from Linux User-space.
7 *
8 * ============================================================================
9 *
10 * Copyright (c) 2012-2013, Texas Instruments Incorporated
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 *
17 * * Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 *
20 * * Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 *
24 * * Neither the name of Texas Instruments Incorporated nor the names of
25 * its contributors may be used to endorse or promote products derived
26 * from this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
29 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
30 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
32 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
35 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
36 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
37 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
38 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 */
42 /* Standard includes */
43 #include <stdio.h>
44 #include <string.h>
45 #include <stdlib.h>
47 /* XDC includes */
48 #include <xdc/std.h>
49 #include <xdc/runtime/Assert.h>
50 #include <xdc/runtime/System.h>
52 /* BIOS includes */
53 #include <ti/sysbios/BIOS.h>
54 #include <ti/sysbios/knl/Task.h>
56 /* IPC includes */
57 #include <ti/ipc/MultiProc.h>
58 #include <ti/ipc/HeapBufMP.h>
59 #include <ti/ipc/MessageQ.h>
61 /* CSL includes */
62 #include <ti/csl/csl_chip.h>
64 /* RM Includes */
65 #include <ti/drv/rm/rm.h>
66 #include <ti/drv/rm/rm_transport.h>
67 #include <ti/drv/rm/rm_services.h>
69 /**********************************************************************
70 ************************** RM Test Symbols ***************************
71 **********************************************************************/
73 /* Test will run on this core */
74 #define TEST_CORE 0
76 /* Test FALSE */
77 #define RM_TEST_FALSE 0
78 /* Test TRUE */
79 #define RM_TEST_TRUE 1
81 /* RM packet heap name */
82 #define MSGQ_HEAP_ID 0
84 /* MessageQ Name for DSP RM Client */
85 #define CLIENT_MESSAGEQ_NAME "RM_CLIENT"
87 /* Size of RM static allocation response queue. Must be greater than number of APPROVED
88 * static allocations */
89 #define MAX_STATIC_ALLOCATION_RESPS 5
91 /* Size of RM service response queue */
92 #define MAX_QUEUED_SERVICE_RESPONSES 10
94 /* Error checking macro */
95 #define ERROR_CHECK(checkVal, resultVal, rmInstName, printMsg) \
96 if (resultVal != checkVal) { \
97 char errorMsgToPrint[] = printMsg; \
98 System_printf("Error Core %d : %s : ", coreNum, rmInstName); \
99 System_printf("%s with error code : %d\n", errorMsgToPrint, resultVal); \
100 testErrors++; \
101 System_abort("Test Failure\n"); \
102 }
104 #define POSITIVE_PASS_CHECK(title, core, instName, resName, resStart, resLen, align, state, check) \
105 do { \
106 int32_t start = resStart; \
107 int32_t alignment = align; \
108 char titleMsg[] = title; \
109 System_printf ("Core %d : ---------------------------------------------------------\n", \
110 core); \
111 System_printf ("Core %d : %s\n", core, titleMsg); \
112 System_printf ("Core %d : - Instance Name: %-32s -\n", core, instName); \
113 System_printf ("Core %d : - Resource Name: %-32s -\n", core, resName); \
114 if (start == RM_RESOURCE_BASE_UNSPECIFIED) { \
115 System_printf ("Core %d : - Start: UNSPECIFIED -\n", \
116 core); \
117 System_printf ("Core %d : - Length: %-16d -\n", \
118 core, resLen); \
119 } \
120 else { \
121 System_printf ("Core %d : - Start: %-16d -\n", \
122 core, resStart); \
123 System_printf ("Core %d : - End: %-16d -\n", core, \
124 (start + resLen - 1)); \
125 } \
126 if (alignment == RM_RESOURCE_ALIGNMENT_UNSPECIFIED) { \
127 System_printf ("Core %d : - Alignment: UNSPECIFIED -\n", \
128 core); \
129 } \
130 else { \
131 System_printf ("Core %d : - Alignment: %-16d -\n", \
132 core, alignment); \
133 } \
134 System_printf ("Core %d : - -\n", \
135 core); \
136 if (state == check) { \
137 System_printf ("Core %d : - PASSED -\n", \
138 core); \
139 } \
140 else { \
141 System_printf ("Core %d : - FAILED - Denial: %-6d -\n", \
142 core, state); \
143 testErrors++; \
144 } \
145 System_printf ("Core %d : ---------------------------------------------------------\n", \
146 core); \
147 System_printf ("\n"); \
148 } while(0);
150 #define NEGATIVE_PASS_CHECK(title, core, instName, resName, resStart, resLen, align, state, check) \
151 do { \
152 int32_t start = resStart; \
153 int32_t alignment = align; \
154 char titleMsg[] = title; \
155 System_printf ("Core %d : ---------------------------------------------------------\n", \
156 core); \
157 System_printf ("Core %d : %s\n", core, titleMsg); \
158 System_printf ("Core %d : - Instance Name: %-32s -\n", core, instName); \
159 System_printf ("Core %d : - Resource Name: %-32s -\n", core, resName); \
160 if (start == RM_RESOURCE_BASE_UNSPECIFIED) { \
161 System_printf ("Core %d : - Start: UNSPECIFIED -\n", \
162 core); \
163 System_printf ("Core %d : - Length: %-16d -\n", \
164 core, resLen); \
165 } \
166 else { \
167 System_printf ("Core %d : - Start: %-16d -\n", \
168 core, resStart); \
169 System_printf ("Core %d : - End: %-16d -\n", core, \
170 (start + resLen - 1)); \
171 } \
172 if (alignment == RM_RESOURCE_ALIGNMENT_UNSPECIFIED) { \
173 System_printf ("Core %d : - Alignment: UNSPECIFIED -\n", \
174 core); \
175 } \
176 else { \
177 System_printf ("Core %d : - Alignment: %-16d -\n", \
178 core, alignment); \
179 } \
180 System_printf ("Core %d : - -\n", \
181 core); \
182 if (state != check) { \
183 System_printf ("Core %d : - PASSED - Denial: %-6d -\n", \
184 core, state); \
185 } \
186 else { \
187 System_printf ("Core %d : - FAILED - Expected Denial -\n", \
188 core); \
189 testErrors++; \
190 } \
191 System_printf ("Core %d : ---------------------------------------------------------\n", \
192 core); \
193 System_printf ("\n"); \
194 } while(0);
196 #define STATUS_PASS_CHECK(title, core, instName, resName, resStart, resLen, refCnt, state, check, expectRefCnt) \
197 do { \
198 int32_t start = resStart; \
199 char titleMsg[] = title; \
200 System_printf ("Core %d : ---------------------------------------------------------\n", \
201 core); \
202 System_printf ("Core %d : %s\n", core, titleMsg); \
203 System_printf ("Core %d : - Instance Name: %-32s -\n", core, instName); \
204 System_printf ("Core %d : - Resource Name: %-32s -\n", core, resName); \
205 System_printf ("Core %d : - Start: %-16d -\n", \
206 core, resStart); \
207 System_printf ("Core %d : - End: %-16d -\n", core, \
208 (start + resLen - 1)); \
209 System_printf ("Core %d : - Expected Owner Count: %-16d -\n", \
210 core, expectRefCnt); \
211 System_printf ("Core %d : - Returned Owner Count: %-16d -\n", \
212 core, refCnt); \
213 System_printf ("Core %d : - -\n", core); \
214 if ((state == check) && (refCnt == expectRefCnt)) { \
215 System_printf ("Core %d : - PASSED -\n", core); \
216 } \
217 else { \
218 if (refCnt != expectRefCnt) { \
219 System_printf ("Core %d : - FAILED - Owner Count Mismatch -\n", \
220 core); \
221 } \
222 else { \
223 System_printf ("Core %d : - FAILED - Denial: %-6d -\n", \
224 core, state); \
225 } \
226 testErrors++; \
227 } \
228 System_printf ("Core %d : ---------------------------------------------------------\n", \
229 core); \
230 System_printf ("\n"); \
231 } while(0);
233 /**********************************************************************
234 ********************** RM Test Data Structures ***********************
235 **********************************************************************/
237 /* IPC MessageQ RM packet encapsulation structure */
238 typedef struct {
239 /* IPC MessageQ header (must be first element in structure) */
240 MessageQ_MsgHeader msgQHeader;
241 /* Pointer to RM packet */
242 Rm_Packet rmPkt;
243 } MsgQ_RmPacket;
245 /**********************************************************************
246 ********************** Extern Variables ******************************
247 **********************************************************************/
249 /* Alloc and free OSAL variables */
250 extern uint32_t rmMallocCounter;
251 extern uint32_t rmFreeCounter;
253 /* RM test Static Policy provided to RM Client */
254 extern const char rmStaticPolicy[];
256 /**********************************************************************
257 ********************** Global Variables ******************************
258 **********************************************************************/
260 /* Core number */
261 uint16_t coreNum;
262 /* Number of errors that occurred during the test */
263 uint16_t testErrors;
265 /* Task to configure application transport code for RM */
266 Task_Handle rmStartupTskHandle;
267 /* High priority task for receiving RM packets */
268 Task_Handle rmReceiveTskHandle;
269 /* RM client delegate and client test task */
270 Task_Handle rmClientTskHandle;
272 /* Handle for heap that RM packets will be allocated from */
273 HeapBufMP_Handle rmPktHeapHandle = NULL;
275 /* Client instance name (must match with RM Global Resource List (GRL) and policies */
276 char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
278 /* Client MessageQ */
279 MessageQ_Handle rmClientQ = NULL;
281 /* Linux MessageQ ID */
282 MessageQ_QueueId linuxQueueId;
284 /* Client instance handles */
285 Rm_Handle rmClientHandle = NULL;
287 /* Client instance service handles */
288 Rm_ServiceHandle *rmClientServiceHandle = NULL;
290 /* Client from Server transport handle */
291 Rm_TransportHandle clientFromServerTransportHandle;
293 /* Static allocation response queue */
294 Rm_ServiceRespInfo staticResponseQueue[MAX_STATIC_ALLOCATION_RESPS];
295 /* Static allocation response queue index */
296 uint32_t numStaticResponses;
298 /* RM response info queue used to store service responses received via the callback function */
299 Rm_ServiceRespInfo responseInfoQueue[MAX_QUEUED_SERVICE_RESPONSES];
301 /* RM resource names (must match resource node names in GRL and policies */
302 char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions";
303 char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch";
304 char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue";
305 char resourceNameAifQ[RM_NAME_MAX_CHARS] = "aif-queue";
306 char resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster";
307 char resourceNameAifRxCh[RM_NAME_MAX_CHARS] = "aif-rx-ch";
308 char resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
310 /* Test RM NameServer name */
311 char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
313 /**********************************************************************
314 *************************** Test Functions ***************************
315 **********************************************************************/
317 Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
318 {
319 Rm_Packet *rmPkt = NULL;
320 MsgQ_RmPacket *rmMsg = NULL;
322 /* Allocate a messageQ message for containing the RM packet */
323 rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket));
324 if (rmMsg == NULL) {
325 System_printf("Error Core %d : MessageQ_alloc failed to allocate message: %d\n", coreNum);
326 testErrors++;
327 *pktHandle = NULL;
328 return(NULL);
329 }
330 else {
331 rmPkt = &(rmMsg->rmPkt);
332 rmPkt->pktLenBytes = pktSize;
333 *pktHandle = (Rm_PacketHandle)rmMsg;
334 }
335 return (rmPkt);
336 }
338 void transportFree (MessageQ_Msg rmMsgQMsg)
339 {
340 int32_t status;
342 status = MessageQ_free(rmMsgQMsg);
343 if (status < 0) {
344 System_printf("Error Core %d : MessageQ_free failed to free message: %d\n", coreNum, status);
345 testErrors++;
346 }
347 }
349 int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
350 {
351 MessageQ_QueueId *remoteQueueId = (MessageQ_QueueId *)appTransport;
352 MsgQ_RmPacket *rmMsg = pktHandle;
353 int32_t status;
355 /* Send the message to Linux */
356 status = MessageQ_put(*remoteQueueId, (MessageQ_Msg)rmMsg);
357 if (status < 0) {
358 System_printf("Error Core %d : MessageQ_put failed to send message: %d\n", coreNum, status);
359 testErrors++;
360 }
362 return (0);
363 }
365 void transportReceive (void)
366 {
367 int32_t numPkts;
368 MessageQ_Msg rmMsg = NULL;
369 Rm_Packet *rmPkt = NULL;
370 int32_t status;
371 uint32_t i;
373 /* Check if any packets available */
374 numPkts = (int32_t) MessageQ_count(rmClientQ);
376 /* Process all available packets */
377 for (i = 0; i < numPkts; i++) {
378 status = (int32_t) MessageQ_get(rmClientQ, &rmMsg, MessageQ_FOREVER);
379 if (rmMsg == NULL) {
380 System_printf("Error Core %d : MessageQ_get failed, returning a NULL packet\n", coreNum);
381 testErrors++;
382 }
384 /* Extract the Rm_Packet from the RM msg */
385 rmPkt = &(((MsgQ_RmPacket *)rmMsg)->rmPkt);
387 /* Provide packet to RM for processing */
388 if (status = Rm_receivePacket(clientFromServerTransportHandle, rmPkt)) {
389 System_printf("Error Core %d : RM failed to process received packet: %d\n", coreNum, status);
390 testErrors++;
391 }
393 /* Free RM packet buffer and messageQ message */
394 transportFree(rmMsg);
395 }
396 }
398 void serviceCallback(Rm_ServiceRespInfo *serviceResponse)
399 {
400 uint32_t qIndex = 0;
402 /* Populate next free entry in the responseInfoQueue */
403 while (responseInfoQueue[qIndex].serviceId != 0) {
404 qIndex++;
405 if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
406 qIndex = 0;
407 }
408 }
410 /* Save the response in the response queue for the test task to pick up */
411 memcpy((void *)&responseInfoQueue[qIndex], (void *)serviceResponse, sizeof(Rm_ServiceRespInfo));
412 }
414 /* Packets received via rpmsg port will issue callback vai transportReceive function */
415 void waitForResponse(Rm_ServiceRespInfo *respInfo)
416 {
417 uint32_t qIndex = 0;
419 if ((respInfo->serviceState == RM_SERVICE_PROCESSING) ||
420 (respInfo->serviceState == RM_SERVICE_PENDING_SERVER_RESPONSE)) {
421 /* Scan responseInfoQueue for the response received via the callback function */
422 while((responseInfoQueue[qIndex].serviceId != respInfo->serviceId) ||
423 (responseInfoQueue[qIndex].rmHandle != respInfo->rmHandle)) {
424 qIndex++;
425 if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
426 qIndex = 0;
427 }
429 /* Higher priority receive task will retrieve response */
430 }
432 memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(Rm_ServiceRespInfo));
433 memset((void *)&responseInfoQueue[qIndex], 0, sizeof(Rm_ServiceRespInfo));
434 }
435 }
437 void setRmRequest(Rm_ServiceReqInfo *reqInfo, Rm_ServiceType type, const char *resName, int32_t resBase,
438 uint32_t resLen, int32_t resAlign, const char *nsName, int setCallback, Rm_ServiceRespInfo *respInfo)
439 {
440 memset((void *)reqInfo, 0, sizeof(Rm_ServiceReqInfo));
441 reqInfo->type = type;
442 reqInfo->resourceName = resName;
443 reqInfo->resourceBase = resBase;
444 reqInfo->resourceLength = resLen;
445 reqInfo->resourceAlignment = resAlign;
446 reqInfo->resourceNsName = nsName;
447 if (setCallback) {
448 reqInfo->callback.serviceCallback = serviceCallback;
449 }
450 memset((void *)respInfo, 0, sizeof(Rm_ServiceRespInfo));
451 }
453 void rmCleanupTsk(UArg arg0, UArg arg1)
454 {
455 Rm_ServiceReqInfo requestInfo;
456 Rm_ServiceRespInfo responseInfo;
457 int32_t result;
458 int32_t finalMallocFree;
460 /* Free all allocated resources */
461 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAccumCh,
462 0, 7, 0, NULL, RM_TEST_TRUE, &responseInfo);
463 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
464 waitForResponse(&responseInfo);
465 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
466 coreNum, rmClientName, responseInfo.resourceName,
467 responseInfo.resourceBase, responseInfo.resourceLength,
468 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
469 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAccumCh,
470 40, 2, 0, NULL, RM_TEST_TRUE, &responseInfo);
471 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
472 waitForResponse(&responseInfo);
473 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
474 coreNum, rmClientName, responseInfo.resourceName,
475 responseInfo.resourceBase, responseInfo.resourceLength,
476 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
478 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameQosCluster,
479 0, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
480 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
481 waitForResponse(&responseInfo);
482 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
483 coreNum, rmClientName, responseInfo.resourceName,
484 responseInfo.resourceBase, responseInfo.resourceLength,
485 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
486 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameQosCluster,
487 2, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
488 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
489 waitForResponse(&responseInfo);
490 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
491 coreNum, rmClientName, responseInfo.resourceName,
492 responseInfo.resourceBase, responseInfo.resourceLength,
493 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
495 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifQ,
496 525, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
497 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
498 waitForResponse(&responseInfo);
499 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
500 coreNum, rmClientName, responseInfo.resourceName,
501 responseInfo.resourceBase, responseInfo.resourceLength,
502 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
504 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifQ,
505 525, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
506 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
507 waitForResponse(&responseInfo);
508 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
509 coreNum, rmClientName, responseInfo.resourceName,
510 responseInfo.resourceBase, responseInfo.resourceLength,
511 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
513 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameInfraQ,
514 800, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
515 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
516 waitForResponse(&responseInfo);
517 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
518 coreNum, rmClientName, responseInfo.resourceName,
519 responseInfo.resourceBase, responseInfo.resourceLength,
520 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
522 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ,
523 7000, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
524 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
525 waitForResponse(&responseInfo);
526 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
527 coreNum, rmClientName, responseInfo.resourceName,
528 responseInfo.resourceBase, responseInfo.resourceLength,
529 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
531 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ,
532 7011, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
533 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
534 waitForResponse(&responseInfo);
535 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
536 coreNum, rmClientName, responseInfo.resourceName,
537 responseInfo.resourceBase, responseInfo.resourceLength,
538 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
540 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ,
541 7010, 5, 0, NULL, RM_TEST_TRUE, &responseInfo);
542 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
543 waitForResponse(&responseInfo);
544 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
545 coreNum, rmClientName, responseInfo.resourceName,
546 responseInfo.resourceBase, responseInfo.resourceLength,
547 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
549 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameGpQ,
550 7005, 25, 0, NULL, RM_TEST_TRUE, &responseInfo);
551 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
552 waitForResponse(&responseInfo);
553 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
554 coreNum, rmClientName, responseInfo.resourceName,
555 responseInfo.resourceBase, responseInfo.resourceLength,
556 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
558 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifRxCh,
559 0, 6, 0, NULL, RM_TEST_TRUE, &responseInfo);
560 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
561 waitForResponse(&responseInfo);
562 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
563 coreNum, rmClientName, responseInfo.resourceName,
564 responseInfo.resourceBase, responseInfo.resourceLength,
565 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
566 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifRxCh,
567 50, 7, 0, NULL, RM_TEST_TRUE, &responseInfo);
568 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
569 waitForResponse(&responseInfo);
570 POSITIVE_PASS_CHECK("-------------------- Resource Cleanup -------------------",
571 coreNum, rmClientName, responseInfo.resourceName,
572 responseInfo.resourceBase, responseInfo.resourceLength,
573 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
575 /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
576 result = Rm_serviceCloseHandle(rmClientServiceHandle);
577 ERROR_CHECK(RM_OK, result, rmClientName, "Service handle close failed");
579 result = Rm_transportUnregister(clientFromServerTransportHandle);
580 ERROR_CHECK(RM_OK, result, rmClientName, "Unregister of Server transport failed");
582 result = MessageQ_delete(&rmClientQ);
583 if (result < 0) {
584 System_printf("Core %d : Error in MessageQ_delete [%d]\n", coreNum, result);
585 testErrors++;
586 }
588 result = Rm_delete(rmClientHandle, RM_TEST_TRUE);
589 ERROR_CHECK(RM_OK, result, rmClientName, "Instance delete failed");
591 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
592 System_printf ("Core %d : ------------------ Memory Leak Check --------------------\n", coreNum);
593 System_printf ("Core %d : - : malloc count | free count -\n", coreNum);
594 System_printf ("Core %d : - Example Completion : %6d | %6d -\n", coreNum,
595 rmMallocCounter, rmFreeCounter);
596 finalMallocFree = rmMallocCounter - rmFreeCounter;
597 if (finalMallocFree > 0) {
598 System_printf ("Core %d : - FAILED - %6d unfreed mallocs -\n",
599 coreNum, finalMallocFree);
600 testErrors++;
601 }
602 else if (finalMallocFree < 0) {
603 System_printf ("Core %d : - FAILED - %6d more frees than mallocs -\n",
604 coreNum, -finalMallocFree);
605 testErrors++;
606 }
607 else {
608 System_printf ("Core %d : - PASSED -\n",
609 coreNum);
610 }
611 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
612 System_printf ("\n");
614 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
615 System_printf ("Core %d : ------------------ Example Completion -------------------\n", coreNum);
616 if (testErrors) {
617 System_printf ("Core %d : - Test Errors: %-32d -\n", coreNum, testErrors);
618 }
619 System_printf ("Core %d : ---------------------------------------------------------\n", coreNum);
620 System_printf ("\n");
621 }
623 /* Receive task has priority of 2 so that it pre-empts the RM instance test tasks */
624 void rmReceiveTsk(UArg arg0, UArg arg1)
625 {
626 while(1) {
627 transportReceive();
628 /* Sleep for 1ms so that the main test tasks can run */
629 Task_sleep(1);
630 }
631 }
633 void rmClientTsk(UArg arg0, UArg arg1)
634 {
635 Rm_ServiceReqInfo requestInfo;
636 Rm_ServiceRespInfo responseInfo;
637 Task_Params taskParams;
638 uint32_t i, j;
640 /* Create new NameServer object */
641 setRmRequest(&requestInfo, Rm_service_RESOURCE_MAP_TO_NAME, resourceNameGpQ,
642 1002, 1, 0, nameServerNameFavQ, RM_TEST_TRUE, &responseInfo);
643 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
644 waitForResponse(&responseInfo);
645 POSITIVE_PASS_CHECK("--------------- Create NameServer Object ----------------",
646 coreNum, rmClientName, resourceNameGpQ,
647 requestInfo.resourceBase, responseInfo.resourceLength,
648 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
650 /* Retrieve a resource via a NameServer name */
651 setRmRequest(&requestInfo, Rm_service_RESOURCE_GET_BY_NAME, NULL,
652 0, 0, 0, nameServerNameFavQ, RM_TEST_TRUE, &responseInfo);
653 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
654 waitForResponse(&responseInfo);
655 POSITIVE_PASS_CHECK("------- Retrieve Resource Via NameServer Object ---------",
656 coreNum, rmClientName, responseInfo.resourceName,
657 responseInfo.resourceBase, responseInfo.resourceLength,
658 0, responseInfo.serviceState, RM_SERVICE_APPROVED);
660 /* Allocate the resource returned from the NameServer request */
661 memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
662 requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT;
663 requestInfo.resourceName = responseInfo.resourceName;
664 requestInfo.resourceBase = responseInfo.resourceBase;
665 requestInfo.resourceLength = responseInfo.resourceLength;
666 requestInfo.resourceNsName = NULL;
667 requestInfo.callback.serviceCallback = serviceCallback;
668 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
669 waitForResponse(&responseInfo);
670 POSITIVE_PASS_CHECK("-------- Init Allocate Using Retrieved Resource ---------",
671 coreNum, rmClientName, responseInfo.resourceName,
672 requestInfo.resourceBase, requestInfo.resourceLength,
673 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
675 /* Retrieve the resource status via the NameServer name */
676 setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, NULL,
677 0, 0, 0, nameServerNameFavQ, RM_TEST_TRUE, &responseInfo);
678 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
679 waitForResponse(&responseInfo);
680 STATUS_PASS_CHECK("---- Retrieve Resource Status Via NameServer Object -----",
681 coreNum, rmClientName, responseInfo.resourceName,
682 responseInfo.resourceBase, responseInfo.resourceLength,
683 responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 1);
685 /* Free resource via a NameServer name */
686 setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, NULL,
687 0, 0, 0, nameServerNameFavQ, RM_TEST_TRUE, &responseInfo);
688 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
689 waitForResponse(&responseInfo);
690 POSITIVE_PASS_CHECK("--- Free of Retrieved Resource Using NameServer Name ----",
691 coreNum, rmClientName, nameServerNameFavQ,
692 0, 1, 0, responseInfo.serviceState, RM_SERVICE_APPROVED);
694 /* Delete the NameServer name */
695 setRmRequest(&requestInfo, Rm_service_RESOURCE_UNMAP_NAME, NULL,
696 0, 0, 0, nameServerNameFavQ, RM_TEST_TRUE, &responseInfo);
697 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
698 waitForResponse(&responseInfo);
699 POSITIVE_PASS_CHECK("--------------- Delete NameServer Object ----------------",
700 coreNum, rmClientName, nameServerNameFavQ,
701 0, 1, 0, responseInfo.serviceState, RM_SERVICE_APPROVED);
703 /* BEGIN testing expansion/contraction of resource nodes with the AIF RX CH resource */
704 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
705 0, 6, 0, NULL, RM_TEST_TRUE, &responseInfo);
706 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
707 waitForResponse(&responseInfo);
708 POSITIVE_PASS_CHECK("- Resource Node Expand/Contract Testing (Use Allocate) --",
709 coreNum, rmClientName, resourceNameAifRxCh,
710 requestInfo.resourceBase, requestInfo.resourceLength,
711 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
713 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifRxCh,
714 50, 7, 0, NULL, RM_TEST_TRUE, &responseInfo);
715 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
716 waitForResponse(&responseInfo);
717 POSITIVE_PASS_CHECK("- Resource Node Expand/Contract Testing (Init Allocate) -",
718 coreNum, rmClientName, resourceNameAifRxCh,
719 requestInfo.resourceBase, requestInfo.resourceLength,
720 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
721 /* END testing expansion/contraction of resource nodes with the AIF RX CH resource */
723 /* BEGIN testing allocations with UNSPECIFIED base and alignment values */
724 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
725 RM_RESOURCE_BASE_UNSPECIFIED, 5, 4, NULL, RM_TEST_TRUE, &responseInfo);
726 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
727 waitForResponse(&responseInfo);
728 POSITIVE_PASS_CHECK("---------- Use Allocation w/ UNSPECIFIED Base -----------",
729 coreNum, rmClientName, resourceNameAccumCh,
730 RM_RESOURCE_BASE_UNSPECIFIED, requestInfo.resourceLength,
731 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
733 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
734 RM_RESOURCE_BASE_UNSPECIFIED, 2, 1, NULL, RM_TEST_TRUE, &responseInfo);
735 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
736 waitForResponse(&responseInfo);
737 POSITIVE_PASS_CHECK("---------- Use Allocation w/ UNSPECIFIED Base -----------",
738 coreNum, rmClientName, resourceNameAccumCh,
739 RM_RESOURCE_BASE_UNSPECIFIED, requestInfo.resourceLength,
740 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
742 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
743 RM_RESOURCE_BASE_UNSPECIFIED, 2, RM_RESOURCE_ALIGNMENT_UNSPECIFIED, NULL, RM_TEST_TRUE, &responseInfo);
744 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
745 waitForResponse(&responseInfo);
746 POSITIVE_PASS_CHECK("---- Use Allocation w/ UNSPECIFIED Base & Alignment -----",
747 coreNum, rmClientName, resourceNameAccumCh,
748 RM_RESOURCE_BASE_UNSPECIFIED, requestInfo.resourceLength,
749 RM_RESOURCE_ALIGNMENT_UNSPECIFIED, responseInfo.serviceState, RM_SERVICE_APPROVED);
750 /* END testing allocations with UNSPECIFIED base and alignment values */
752 /* Allocate infrastructure queue shared between Linux kernel and Client */
753 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameInfraQ,
754 800, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
755 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
756 waitForResponse(&responseInfo);
757 POSITIVE_PASS_CHECK("-- Init Allocation of Shared Linux and Client Resource --",
758 coreNum, rmClientName, resourceNameInfraQ,
759 requestInfo.resourceBase, requestInfo.resourceLength,
760 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
762 /* BEGIN Allocating some resources without providing a callback function. RM should block and not return until the result
763 * is returned by the server. */
764 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ,
765 7000, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
766 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
767 waitForResponse(&responseInfo);
768 POSITIVE_PASS_CHECK("- Init Allocation (RM Blocked Until Resource Returned) --",
769 coreNum, rmClientName, resourceNameGpQ,
770 requestInfo.resourceBase, requestInfo.resourceLength,
771 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
773 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
774 7005, 25, 0, NULL, RM_TEST_TRUE, &responseInfo);
775 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
776 waitForResponse(&responseInfo);
777 POSITIVE_PASS_CHECK("-- Use Allocation (RM Blocked Until Resource Returned) --",
778 coreNum, rmClientName, resourceNameGpQ,
779 requestInfo.resourceBase, requestInfo.resourceLength,
780 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
782 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
783 7010, 5, 0, NULL, RM_TEST_TRUE, &responseInfo);
784 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
785 waitForResponse(&responseInfo);
786 POSITIVE_PASS_CHECK("-- Use Allocation (RM Blocked Until Resource Returned) --",
787 coreNum, rmClientName, resourceNameGpQ,
788 requestInfo.resourceBase, requestInfo.resourceLength,
789 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
791 /* Init allocation of resource already owned by Client should return approved and there should only
792 * be one instance of Client in resource's owner list. */
793 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ,
794 7011, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
795 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
796 waitForResponse(&responseInfo);
797 POSITIVE_PASS_CHECK("----- Use Allocation of Owned Resource (RM Blocked) -----",
798 coreNum, rmClientName, resourceNameGpQ,
799 requestInfo.resourceBase, requestInfo.resourceLength,
800 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED);
801 /* END Allocating some resources without providing a callback function. RM should block and not return
802 * until the result is returned by the Server. */
804 /* BEGIN Getting the status of resources from Client and CD */
805 setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, resourceNameGpQ,
806 7012, 2, 0, NULL, RM_TEST_TRUE, &responseInfo);
807 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
808 waitForResponse(&responseInfo);
809 STATUS_PASS_CHECK("-- Status Check of Resources from Client (Non-Blocking) -",
810 coreNum, rmClientName, responseInfo.resourceName,
811 responseInfo.resourceBase, responseInfo.resourceLength,
812 responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 1);
814 setRmRequest(&requestInfo, Rm_service_RESOURCE_STATUS, resourceNameGpQ,
815 4025, 20, 0, NULL, RM_TEST_TRUE, &responseInfo);
816 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
817 waitForResponse(&responseInfo);
818 STATUS_PASS_CHECK("---- Status Check of Resources from Client (Blocking) ---",
819 coreNum, rmClientName, responseInfo.resourceName,
820 responseInfo.resourceBase, responseInfo.resourceLength,
821 responseInfo.resourceNumOwners, responseInfo.serviceState, RM_SERVICE_APPROVED, 1);
822 /* END Getting the status of resources from Client and CD */
824 /* Verify static allocations were validated. Validation responses should have been received after the
825 * first service requests were made on the Client and CD post transport path registration. */
826 while (numStaticResponses > 0) {
827 /* Loop until all static request validations have been received */
828 for (i = 0; i < MAX_STATIC_ALLOCATION_RESPS; i++) {
829 if (staticResponseQueue[i].serviceId != 0) {
830 for (j = 0; j < MAX_QUEUED_SERVICE_RESPONSES; j++) {
831 if ((staticResponseQueue[i].serviceId == responseInfoQueue[j].serviceId) &&
832 (staticResponseQueue[i].rmHandle == responseInfoQueue[j].rmHandle)) {
833 POSITIVE_PASS_CHECK("------------- Static Allocation Validation --------------",
834 coreNum, rmClientName, responseInfoQueue[j].resourceName,
835 responseInfoQueue[j].resourceBase, responseInfoQueue[j].resourceLength,
836 0, responseInfoQueue[j].serviceState,
837 RM_SERVICE_APPROVED);
838 memset((void *)&staticResponseQueue[i], 0, sizeof(Rm_ServiceRespInfo));
839 memset((void *)&responseInfoQueue[j], 0, sizeof(Rm_ServiceRespInfo));
840 numStaticResponses--;
841 break;
842 }
843 }
844 }
845 }
846 }
848 /* Create the RM cleanup task. */
849 System_printf("Core %d : Creating RM cleanup task...\n", coreNum);
850 Task_Params_init (&taskParams);
851 Task_create (rmCleanupTsk, &taskParams, NULL);
852 }
854 void rmStartupTsk(UArg arg0, UArg arg1)
855 {
856 Task_Params taskParams;
857 Char localQueueName[64];
858 MessageQ_Msg msg;
859 Rm_TransportCfg rmTransCfg;
860 int32_t rm_result;
862 /* Construct a MessageQ name adorned with core name: */
863 System_sprintf(localQueueName, "%s_%s", CLIENT_MESSAGEQ_NAME,
864 MultiProc_getName(MultiProc_self()));
866 rmClientQ = MessageQ_create(localQueueName, NULL);
867 if (rmClientQ == NULL) {
868 System_abort("MessageQ_create failed\n");
869 }
871 if (coreNum == TEST_CORE) {
872 System_printf("Awaiting sync message from host...\n");
873 MessageQ_get(rmClientQ, &msg, MessageQ_FOREVER);
875 linuxQueueId = MessageQ_getReplyQueue(msg);
876 MessageQ_put(linuxQueueId, msg);
878 /* Register the Server with the Client instance */
879 rmTransCfg.rmHandle = rmClientHandle;
880 rmTransCfg.appTransportHandle = (Rm_AppTransportHandle) &linuxQueueId;
881 rmTransCfg.remoteInstType = Rm_instType_SERVER;
882 rmTransCfg.transportCallouts.rmAllocPkt = transportAlloc;
883 rmTransCfg.transportCallouts.rmSendPkt = transportSend;
884 clientFromServerTransportHandle = Rm_transportRegister(&rmTransCfg, &rm_result);
886 /* Create the RM receive task. Assign higher priority than the test tasks so that
887 * when they spin waiting for messages from other RM instances the receive task is
888 * executed. */
889 System_printf("Core %d : Creating RM receive task...\n", coreNum);
890 Task_Params_init (&taskParams);
891 taskParams.priority = 2;
892 rmReceiveTskHandle = Task_create (rmReceiveTsk, &taskParams, NULL);
894 System_printf("Core %d : Creating RM client task...\n", coreNum);
895 Task_Params_init (&taskParams);
896 taskParams.priority = 1;
897 rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
898 }
899 }
901 int main(int argc, char *argv[])
902 {
903 Task_Params taskParams;
904 Rm_InitCfg rmInitCfg;
905 Rm_ServiceReqInfo requestInfo;
906 Rm_ServiceRespInfo responseInfo;
907 int32_t result;
910 System_printf ("*********************************************************\n");
911 System_printf ("************ RM DSP+ARM DSP Client Testing **************\n");
912 System_printf ("*********************************************************\n");
914 System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
916 coreNum = CSL_chipReadReg(CSL_CHIP_DNUM);
918 if (coreNum == TEST_CORE) {
919 testErrors = 0;
921 /* Initialize the RM Client - RM must be initialized before anything else in the system */
922 memset(&rmInitCfg, 0, sizeof(rmInitCfg));
923 rmInitCfg.instName = rmClientName;
924 rmInitCfg.instType = Rm_instType_CLIENT;
925 rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
926 rmClientHandle = Rm_init(&rmInitCfg, &result);
927 ERROR_CHECK(RM_OK, result, rmClientName, "Initialization failed");
929 System_printf("\n\nInitialized %s\n\n", rmClientName);
931 /* Open Client service handle */
932 rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
933 ERROR_CHECK(RM_OK, result, rmClientName, "Service handle open failed");
935 /* Initialize the static allocation response queue */
936 for (numStaticResponses = 0; numStaticResponses < MAX_STATIC_ALLOCATION_RESPS; numStaticResponses++) {
937 memset((void *)&staticResponseQueue[numStaticResponses], 0, sizeof(Rm_ServiceRespInfo));
938 }
939 numStaticResponses = 0;
941 /* Static allocation tests */
942 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
943 0, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
944 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
945 POSITIVE_PASS_CHECK("---------------- Static Init Allocation -----------------",
946 coreNum, rmClientName, resourceNameQosCluster,
947 requestInfo.resourceBase, requestInfo.resourceLength,
948 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED_STATIC);
949 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
950 memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(responseInfo));
951 }
953 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
954 2, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
955 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
956 POSITIVE_PASS_CHECK("---------------- Static Init Allocation -----------------",
957 coreNum, rmClientName, resourceNameQosCluster,
958 requestInfo.resourceBase, requestInfo.resourceLength,
959 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED_STATIC);
960 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
961 memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(responseInfo));
962 }
964 /* Request resource from Client that can only be allocated to CD according to static policy */
965 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
966 1, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
967 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
968 NEGATIVE_PASS_CHECK("---------------- Static Init Allocation -----------------",
969 coreNum, rmClientName, resourceNameQosCluster,
970 requestInfo.resourceBase, requestInfo.resourceLength,
971 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED_STATIC);
973 /* Request resource from both Client and CD that is shared according to static policy */
974 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifQ,
975 525, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
976 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
977 POSITIVE_PASS_CHECK("---------------- Static Init Allocation -----------------",
978 coreNum, rmClientName, resourceNameAifQ,
979 requestInfo.resourceBase, requestInfo.resourceLength,
980 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED_STATIC);
981 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
982 memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(responseInfo));
983 }
985 setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifQ,
986 525, 1, 0, NULL, RM_TEST_TRUE, &responseInfo);
987 rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
988 POSITIVE_PASS_CHECK("---------------- Static Init Allocation -----------------",
989 coreNum, rmClientName, resourceNameAifQ,
990 requestInfo.resourceBase, requestInfo.resourceLength,
991 requestInfo.resourceAlignment, responseInfo.serviceState, RM_SERVICE_APPROVED_STATIC);
992 if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
993 memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(responseInfo));
994 }
996 }
997 else {
998 System_printf("Core %d : RM DSP+ARM Linux test not executing on this core\n", coreNum);
999 }
1001 /* Create the RM startup task */
1002 System_printf("Core %d : Creating RM startup task...\n", coreNum);
1003 Task_Params_init (&taskParams);
1004 rmStartupTskHandle = Task_create (rmStartupTsk, &taskParams, NULL);
1006 System_printf("Core %d : Starting BIOS...\n", coreNum);
1007 BIOS_start();
1009 return (0);
1010 }