/* * Copyright (c) 2012-2013, Texas Instruments Incorporated * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * * Neither the name of Texas Instruments Incorporated nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ /* * ======== rm_test.c ======== * RM multicore test example * */ #include #include #include #include #include /* -----------------------------------XDC.RUNTIME module Headers */ #include #include /* ----------------------------------- IPC module Headers */ #include #include #include #include /* ----------------------------------- BIOS6 module Headers */ #include #include #include /* ----------------------------------- Resource Manager Headers */ #include #include #include #include /* ----------------------------------- CSL Module Headers */ #include #include #include /* ======== Task Handles ======== */ Task_Handle startupRmTskHandle; Task_Handle testReceiveTskHandle; Task_Handle testRmTskHandle; /* ======== Application Heaps ======== */ #define RM_PKT_HEAP_NAME "rmHeapBuf" HeapBufMP_Handle rmPktHeapHandle = NULL; #define MSGQ_HEAP_NAME "msgQHeapBuf" #define MSGQ_HEAP_ID 0 /* ======== RM Instance Names ======== */ Char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server"; Char rmClientDelegateName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate"; Char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client"; /* ======== RM IPC MessageQ Names ======== */ Char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue"; Char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue"; Char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue"; Char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue"; /* ======== Test Resource & NameServer Names ======== */ Char resourceNameMemRegion[RM_NAME_MAX_CHARS] = "memory-regions"; char resourceNameAccumCh[RM_NAME_MAX_CHARS] = "accumulator-ch"; Char resourceNameGpQ[RM_NAME_MAX_CHARS] = "gp-queue"; Char resourceNameAifQ[RM_NAME_MAX_CHARS] = "aif-queue"; Char resourceNameQosCluster[RM_NAME_MAX_CHARS] = "qos-cluster"; Char resourceNameAifRxCh[RM_NAME_MAX_CHARS] = "aif-rx-ch"; Char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue"; /* ======== RM Instance Handles ======== */ Rm_Handle rmServerHandle = NULL; Rm_Handle rmClientDelegateHandle = NULL; Rm_Handle rmClientHandle = NULL; /* ======== RM Instance Service Ports ======== */ Rm_ServiceHandle *rmServerServiceHandle = NULL; Rm_ServiceHandle *rmClientDelegateServiceHandle = NULL; Rm_ServiceHandle *rmClientServiceHandle = NULL; /* ======== RM Transport Packet Definition ======== */ typedef struct { MessageQ_MsgHeader msgQHeader; /* Pointer to packet provided by RM */ Rm_Packet *rmPkt; } MsgQ_RmPacket; /* ======== RM Transport Mapping Tables for Application ======== */ /* Core 0 Map Entry Indices */ #define SERVER_TO_CD_MAP_ENTRY 0 /* Core 1 Map Entry Indicies */ #define CD_TO_SERVER_MAP_ENTRY 0 #define CD_TO_CLIENT_MAP_ENTRY 1 #define CLIENT_TO_CD_MAP_ENTRY 2 /* Max map entries across all cores */ #define MAX_MAPPING_ENTRIES 3 typedef struct { Rm_TransportHandle transportHandle; MessageQ_Handle receiveMsgQ; } Transport_MapEntry; /* Core 1 will have three mapping entries * Two map entries for the Client Delegate * One map entry for the Client */ Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES]; uint32_t waitForBlockingOperation = 0; Rm_ServiceRespInfo responseInfo; /* ======== RM Application Sync APIs ======== */ typedef struct { uint32_t sem; uint32_t pad[31]; } syncObj; #pragma DATA_SECTION (testSyncObj, ".syncObj"); #pragma DATA_ALIGN (testSyncObj, 16) syncObj testSyncObj; /** * @b Description * @n * The function is used to indicate that a block of memory is * about to be accessed. If the memory block is cached then this * indicates that the application would need to ensure that the * cache is updated with the data from the actual memory. * * @param[in] ptr * Address of memory block * * @param[in] size * Size of memory block * * @retval * Not Applicable */ void beginMemAccess (void *ptr, uint32_t size) { uint32_t key; key = Hwi_disable(); /* Cleanup the prefetch buffer also. */ CSL_XMC_invalidatePrefetchBuffer(); /* Invalidate L1D cache and wait until operation is complete. * Use this approach if L2 cache is not enabled */ CACHE_invL1d (ptr, size, CACHE_FENCE_WAIT); asm (" nop 4"); asm (" nop 4"); asm (" nop 4"); asm (" nop 4"); Hwi_restore(key); } /** * @b Description * @n * The function is used to indicate that the block of memory has * finished being accessed. If the memory block is cached then the * application would need to ensure that the contents of the cache * are updated immediately to the actual memory. * * @param[in] ptr * Address of memory block * * @param[in] size * Size of memory block * * @retval * Not Applicable */ void endMemAccess (void *ptr, uint32_t size) { uint32_t key; key = Hwi_disable(); /* Writeback L1D cache and wait until operation is complete. * Use this approach if L2 cache is not enabled */ CACHE_wbL1d (ptr, size, CACHE_FENCE_WAIT); asm (" nop 4"); asm (" nop 4"); asm (" nop 4"); asm (" nop 4"); Hwi_restore(key); } void initSyncObj(void) { beginMemAccess((void *) &testSyncObj, sizeof(syncObj)); testSyncObj.sem = 0; endMemAccess((void *) &testSyncObj, sizeof(syncObj)); } void takeSyncObj(void) { beginMemAccess((void *) &testSyncObj, sizeof(syncObj)); testSyncObj.sem = 1; endMemAccess((void *) &testSyncObj, sizeof(syncObj)); } void waitOnSyncObj(void) { do { /* Yield for other tasks */ Task_yield(); beginMemAccess((void *) &testSyncObj, sizeof(syncObj)); } while (testSyncObj.sem == 1); } void releaseSyncObj(void) { beginMemAccess((void *) &testSyncObj, sizeof(syncObj)); testSyncObj.sem = 0; endMemAccess((void *) &testSyncObj, sizeof(syncObj)); } /* ======== RM Application Transport APIs ======== */ Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle) { Rm_Packet *rmPkt = NULL; MsgQ_RmPacket *rmMsg = NULL; /* Allocate a messageQ message for containing the RM packet */ rmMsg = (MsgQ_RmPacket *)MessageQ_alloc(MSGQ_HEAP_ID, sizeof(MsgQ_RmPacket)); if (rmMsg == NULL) { System_printf("Core %d: MessageQ_alloc failed in TransportSend\n", MultiProc_self()); *pktHandle = NULL; return(NULL); } else { /* Create and attach RM packet to MessageQ message. All transports will allocate from the same heap */ rmPkt = HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0); rmPkt->pktLenBytes = pktSize; endMemAccess((void *)rmPkt, rmPkt->pktLenBytes); rmMsg->rmPkt = rmPkt; *pktHandle = (Rm_PacketHandle)rmMsg; } return (rmPkt); } void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt) { uint32_t pktSize = pkt->pktLenBytes; int32_t status; /* All transports will free rmPkts to the same heap */ HeapBufMP_free(rmPktHeapHandle, pkt, pktSize); status = MessageQ_free(rmMsgQMsg); if (status < 0) { System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", MultiProc_self()); } } int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle) { MessageQ_QueueId remoteQueueId = (MessageQ_QueueId)appTransport; MsgQ_RmPacket *rmMsg = pktHandle; int32_t status; /* Write back data that was written by RM after alloc */ endMemAccess((void *)rmMsg->rmPkt, rmMsg->rmPkt->pktLenBytes); /* Send the message to the remote side */ status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg); if (status < 0) { transportFree((MessageQ_Msg)rmMsg, rmMsg->rmPkt); System_printf("Core %d: MessageQ_put had a failure/error in TransportSend: error: %d\n", MultiProc_self(), status); } return (status); } void transportReceive (uint32_t transportMapEntry) { MessageQ_Handle receiveQ; int32_t numPkts; MessageQ_Msg rmMsg = NULL; Rm_Packet *rmPkt = NULL; int32_t status; uint32_t i; /* Check if any packets available */ receiveQ = rmTransportMap[transportMapEntry].receiveMsgQ; numPkts = (int32_t) MessageQ_count(receiveQ); /* Process all available packets */ for (i = 0; i < numPkts; i++) { status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER); if (status < 0) { System_abort("This should not happen since timeout is forever\n"); } if (rmMsg == NULL) { System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self()); } /* Extract the Rm_Packet from the RM msg */ rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt; beginMemAccess((void *) rmPkt, rmPkt->pktLenBytes); /* Provide packet to RM for processing */ if (status = Rm_receivePacket(rmTransportMap[transportMapEntry].transportHandle, rmPkt)) { System_printf("Core %d: RM encountered error processing received packet: %d\n", MultiProc_self(), status); } /* Free RM packet buffer and messageQ message */ transportFree(rmMsg, rmPkt); } } /* * ======== testServiceCallback ======== * Application's callback function given to RM on service requests */ void testServiceCallback(Rm_ServiceRespInfo *serviceResponse) { if (serviceResponse->serviceId == waitForBlockingOperation) { waitForBlockingOperation = 0; strcpy(responseInfo.resourceName, serviceResponse->resourceName); responseInfo.resourceBase = serviceResponse->resourceBase; responseInfo.resourceLength = serviceResponse->resourceLength; responseInfo.serviceState = serviceResponse->serviceState; } else { System_printf("Core %d: validation of static request with ID %d\n", MultiProc_self(), serviceResponse->serviceId); System_printf(" resource: %s, state: %d, base: %d, length: %d\n", serviceResponse->resourceName, serviceResponse->serviceState, serviceResponse->resourceBase, serviceResponse->resourceLength); } } bool blockForResponse(Rm_ServiceRespInfo *respInfo) { waitForBlockingOperation = respInfo->serviceId; /* Block and wait for the response if the RM needed to perform a blocking operation * to complete the request */ while(waitForBlockingOperation) { /* Yield to receive task to see if there are any packets for RM instance */ Task_yield(); } if ((respInfo->serviceState != RM_SERVICE_PROCESSING) && (respInfo->serviceState != RM_SERVICE_APPROVED) && (respInfo->serviceState != RM_SERVICE_APPROVED_STATIC)) { System_printf("Core %d: Service request encountered error or denial: %d\n", MultiProc_self(), respInfo->serviceState); return(FALSE); } return(TRUE); } /* * ======== testRmTsk ======== * RM cleanup task */ void cleanupRmTsk(UArg arg0, UArg arg1) { /* Delete the RM test task */ System_printf("Core %d: Deleting RM test task...\n", MultiProc_self()); if (testRmTskHandle) { Task_delete(&testRmTskHandle); /* Set the task handle to be NULL so that the delete only occurs once */ testRmTskHandle = NULL; } /* Delete the RM receive task */ System_printf("Core %d: Deleting RM receive task...\n", MultiProc_self()); if (testReceiveTskHandle) { Task_delete(&testReceiveTskHandle); /* Set the task handle to be NULL so that the delete only occurs once */ testReceiveTskHandle = NULL; } /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */ BIOS_exit(0); } /* * ======== testRmTsk ======== * RM test task */ void testReceiveTsk(UArg arg0, UArg arg1) { while(1) { if (MultiProc_self() == 0) { transportReceive(SERVER_TO_CD_MAP_ENTRY); } else if (MultiProc_self() == 1) { transportReceive(CD_TO_SERVER_MAP_ENTRY); transportReceive(CD_TO_CLIENT_MAP_ENTRY); transportReceive(CLIENT_TO_CD_MAP_ENTRY); } /* Yield for main test task */ Task_yield(); } } /* * ======== testRmTsk ======== * RM test task */ void testRmTsk(UArg arg0, UArg arg1) { Rm_ServiceReqInfo requestInfo; Task_Params taskParams; int32_t result; /* Delete the RM startup task */ System_printf("Core %d: Deleting RM startup task...\n", MultiProc_self()); if (startupRmTskHandle) { Task_delete(&startupRmTskHandle); /* Set the task handle to be NULL so that the delete only occurs once */ startupRmTskHandle = NULL; } /* Open service ports on all the RM instances to test service requests from the different * RM instances */ if (MultiProc_self() == 0) { rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result); Rm_printInstanceStatus(rmServerHandle); } else if (MultiProc_self() == 1) { /* CD and Client serviceHandles were allocated in main() for static allocations. * just reuse */ Rm_printInstanceStatus(rmClientDelegateHandle); Rm_printInstanceStatus(rmClientHandle); } memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); System_printf("Core %d: Testing NameServer features...\n", MultiProc_self()); /* Use the service ports to test the service requests */ if (MultiProc_self() == 0) { /* Issue the service request create a new NameServer object via the service port */ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 1; requestInfo.resourceAlignment = 0; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Issue the service request create a new NameServer object via the service port */ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 1; requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Issue the service request create a new NameServer object via the service port */ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 1; requestInfo.resourceAlignment = 200; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } Rm_printResourceStatus(rmServerHandle); /* Issue the service request create a new NameServer object via the service port */ requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = 1002; requestInfo.resourceLength = 1; requestInfo.resourceNsName = nameServerNameFavQ; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s creating NameServer object...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s created NameServer object: %s base: %d length: %d\n", MultiProc_self(), rmServerName, nameServerNameFavQ, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Wait for Client Delegate and Client to retrieve resource via the name and allocate it */ waitOnSyncObj(); Rm_printResourceStatus(rmServerHandle); /* Wait for Client to free resource via the NameServer and delete the NameServer object. */ waitOnSyncObj(); Rm_printResourceStatus(rmServerHandle); /* Try to allocate the memory region taken by the Linux Kernel */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameMemRegion; requestInfo.resourceBase = 12; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Trying to reserve memory region taken by Linux...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource (SHOULD NOT HAPPEN): %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Allocate some resources for testing tree interaction with multiple allocations from different instances */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 14; requestInfo.resourceLength = 5; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 19; requestInfo.resourceLength = 31; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Wait for Client and Client Delegate to do their allocates */ waitOnSyncObj(); Rm_printResourceStatus(rmServerHandle); /* Free resources to show tree handling of different frees */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_FREE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 25; requestInfo.resourceLength = 3; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_FREE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 34; requestInfo.resourceLength = 3; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_FREE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 28; requestInfo.resourceLength = 6; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s freed resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 53; requestInfo.resourceLength = 2; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 2; requestInfo.resourceLength = 2; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } Rm_printResourceStatus(rmServerHandle); /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */ waitOnSyncObj(); Rm_printResourceStatus(rmServerHandle); /* Test allocation of a resource twice from the same instance with init and use privileges. Both * should be approved but the instance should only be mentioned once in the resource's owner list */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = 6543; requestInfo.resourceLength = 10; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource for init...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameGpQ; requestInfo.resourceBase = 6543; requestInfo.resourceLength = 10; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating same resource for use...\n", MultiProc_self(), rmServerName); rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocate resource: %s base: %d length: %d\n", MultiProc_self(), rmServerName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } Rm_printResourceStatus(rmServerHandle); } else if (MultiProc_self() == 1) { /* Issue the service request for the resources tied to the name via the service port */ requestInfo.type = Rm_service_RESOURCE_GET_BY_NAME; requestInfo.resourceNsName = nameServerNameFavQ; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s getting resources tied to NameServer object...\n", MultiProc_self(), rmClientDelegateName); rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s got Name: %s base: %d length: %d\n", MultiProc_self(), rmClientDelegateName, nameServerNameFavQ, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Allocate the resources via the service port from the Client */ requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = responseInfo.resourceName; requestInfo.resourceBase = responseInfo.resourceBase; requestInfo.resourceLength = responseInfo.resourceLength; requestInfo.resourceNsName = NULL; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating resources...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resources: %s base: %d length: %d\n", MultiProc_self(), rmClientName, nameServerNameFavQ, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Release the syncObj so Server can print results of NameServer object add and resource allocate */ releaseSyncObj(); /* Take the syncObj to free the name resource via the name, rather than the base+length */ takeSyncObj(); /* Free the named resource using the name via the service port from the Client */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_FREE; requestInfo.resourceNsName = nameServerNameFavQ; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s freeing resource via name...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s freed resource with name: %s\n", MultiProc_self(), rmClientName, nameServerNameFavQ); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Delete the name object from the NameServer */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_UNMAP_NAME; requestInfo.resourceNsName = nameServerNameFavQ; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Deleting NameServer object: %s...\n", MultiProc_self(), rmClientName, nameServerNameFavQ); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s deleted NameServer object: %s\n", MultiProc_self(), rmClientName, nameServerNameFavQ); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Release the syncObj so Server can print results of resource free and NameServer object delete. */ releaseSyncObj(); /* Take the syncObj to allocate resources for testing resource tree interactions. */ takeSyncObj(); /* Allocate some resources for testing tree interaction with multiple allocations from different instances */ memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 0; requestInfo.resourceLength = 6; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmClientName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameAifRxCh; requestInfo.resourceBase = 50; requestInfo.resourceLength = 7; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName); rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmClientDelegateName, requestInfo.resourceName, requestInfo.resourceBase, requestInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Release the syncObj so Server can print results of resource allocations */ releaseSyncObj(); /* Take the syncObj to allocate resources using the UNSPECIFIED parameters. */ takeSyncObj(); memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAccumCh; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 5; requestInfo.resourceAlignment = 4; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientDelegateName); rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmClientDelegateName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAccumCh; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 2; requestInfo.resourceAlignment = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmClientName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *) &requestInfo, 0, sizeof(Rm_ServiceReqInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_USE; requestInfo.resourceName = resourceNameAccumCh; requestInfo.resourceBase = RM_RESOURCE_BASE_UNSPECIFIED; requestInfo.resourceLength = 2; requestInfo.resourceAlignment = RM_RESOURCE_ALIGNMENT_UNSPECIFIED; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s Allocating resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if ((responseInfo.serviceState == RM_SERVICE_APPROVED) || (responseInfo.serviceState == RM_SERVICE_PROCESSING)) { if (blockForResponse(&responseInfo)) { System_printf("Core %d: %s allocated resource: %s base: %d length: %d\n", MultiProc_self(), rmClientName, responseInfo.resourceName, responseInfo.resourceBase, responseInfo.resourceLength); } } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Release the syncObj so Server can print results of resource allocations */ releaseSyncObj(); } System_printf("Core %d: Testing is complete\n", MultiProc_self()); /* Create the RM cleanup task. */ System_printf("Core %d: Creating RM cleanup task...\n", MultiProc_self()); Task_Params_init (&taskParams); Task_create (cleanupRmTsk, &taskParams, NULL); } /* * ======== startupRmTsk ======== * Configures application transports and registers them with RM */ Void startupRmTsk(UArg arg0, UArg arg1) { MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ; MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId; Int status, i; HeapBufMP_Handle msgQHeapHandle; HeapBufMP_Params heapBufParams; Rm_TransportCfg rmTransportCfg; int32_t result = 0; Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle; Task_Params taskParams; if (MultiProc_self() == 1) { /* Take the syncObj on core 1, preparing for RM testing */ takeSyncObj(); } /* Initialize the transport map */ for (i = 0; i < MAX_MAPPING_ENTRIES; i++) { rmTransportMap[i].transportHandle = NULL; } if (MultiProc_self() == 0) { /* Create the heap that will be used to allocate RM messages. This * heap is a multi-processor heap. It will be shared amongst * all RM instances. */ HeapBufMP_Params_init(&heapBufParams); heapBufParams.regionId = 0; heapBufParams.name = RM_PKT_HEAP_NAME; heapBufParams.numBlocks = 64; heapBufParams.blockSize = sizeof(Rm_Packet); rmPktHeapHandle = HeapBufMP_create(&heapBufParams); if (rmPktHeapHandle == NULL) { System_abort("HeapBufMP_create failed for RM packet heap\n" ); } System_printf("Core %d: RM packet heap created\n", MultiProc_self()); /* Create the heap that will be used to allocate messageQ messages. */ HeapBufMP_Params_init(&heapBufParams); heapBufParams.regionId = 0; heapBufParams.name = MSGQ_HEAP_NAME; heapBufParams.numBlocks = 64; heapBufParams.blockSize = sizeof(MsgQ_RmPacket); msgQHeapHandle = HeapBufMP_create(&heapBufParams); if (msgQHeapHandle == NULL) { System_abort("HeapBufMP_create failed MessageQ message heap\n" ); } System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self()); } else { /* Open the heaps created by the other processor. Loop until opened. */ do { status = HeapBufMP_open(RM_PKT_HEAP_NAME, &rmPktHeapHandle); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: RM packet heap opened\n", MultiProc_self()); do { status = HeapBufMP_open(MSGQ_HEAP_NAME, &msgQHeapHandle); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self()); } /* Register the MessageQ heap with MessageQ */ MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID); /* Create the messageQ's for each RM instance connection * Need four queues. Topology will be: * RM Server <---> RM Client Delegate <---> RM Client * 1 queues on RM Server * 2 queues on RM Client Delegate * 1 queues on RM Client */ if (MultiProc_self() == 0) { serverFromCdMsgQ = MessageQ_create(serverFromCdQueueName, NULL); if (serverFromCdMsgQ == NULL) { System_abort("MessageQ_create failed for RM Server - Client Delegate queue\n" ); } System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", MultiProc_self()); } else if (MultiProc_self() == 1) { cdFromServerMsgQ = MessageQ_create(cdFromServerQueueName, NULL); if (cdFromServerMsgQ == NULL) { System_abort("MessageQ_create failed for RM Client Delegate - Server queue\n" ); } System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", MultiProc_self()); cdFromClientMsgQ = MessageQ_create(cdFromClientQueueName, NULL); if (cdFromClientMsgQ == NULL) { System_abort("MessageQ_create failed for RM Client Delegate - Client queue\n" ); } System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", MultiProc_self()); clientFromCdMsgQ = MessageQ_create(clientFromCdQueueName, NULL); if (clientFromCdMsgQ == NULL) { System_abort("MessageQ_create failed for RM Client - Client Delegate queue\n" ); } System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", MultiProc_self()); } /* Open the remote message queues. Also register the RM transports with each RM instance */ if (MultiProc_self() == 0) { /* Open the Client Delegate messageQ from the Server */ do { status = MessageQ_open(cdFromServerQueueName, &serverToCdQId); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self()); /* Register the Client Delegate with the RM Server Instance */ rmTransportCfg.rmHandle = rmServerHandle; rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) serverToCdQId; rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE; rmTransportCfg.remoteInstName = &rmClientDelegateName[0]; /* Set the callouts as valid for the first transport configuration on Server instance */ rmTransportCfg.transportCalloutsValid = true; rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc; rmTransportCfg.transportCallouts.rmSendPkt = transportSend; serverCdHandle = Rm_transportRegister(&rmTransportCfg, &result); /* Store the mapping information in the transport map */ rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle = serverCdHandle; rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ; System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self()); } else if (MultiProc_self() == 1) { /* Open the Server messageQ from the Client Delegate */ do { status = MessageQ_open(serverFromCdQueueName, &cdToServerQId); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self()); /* Register the Server with the RM Client Delegate Instance */ rmTransportCfg.rmHandle = rmClientDelegateHandle; rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToServerQId; rmTransportCfg.remoteInstType = Rm_instType_SERVER; rmTransportCfg.remoteInstName = &rmServerName[0]; /* Set the callouts as valid for the first transport configuration on Client Delegate instance */ rmTransportCfg.transportCalloutsValid = true; rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc; rmTransportCfg.transportCallouts.rmSendPkt = transportSend; cdServerHandle = Rm_transportRegister(&rmTransportCfg, &result); /* Store the mapping information in the transport map */ rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle = cdServerHandle; rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ; System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self()); /* Open the Client messageQ from the Client Delegate */ do { status = MessageQ_open(clientFromCdQueueName, &cdToClientQId); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self()); /* Register the Client with the RM Client Delegate Instance */ rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) cdToClientQId; rmTransportCfg.remoteInstType = Rm_instType_CLIENT; rmTransportCfg.remoteInstName = &rmClientName[0]; /* Callouts already set on the Client Delegate so set them as invalid */ rmTransportCfg.transportCalloutsValid = false; cdClientHandle = Rm_transportRegister(&rmTransportCfg, &result); /* Store the mapping information in the transport map */ rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle = cdClientHandle; rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ; System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self()); /* Open the Client Delegate messageQ from the Client */ do { status = MessageQ_open(cdFromClientQueueName, &clientToCdQId); /* * Sleep for 1 clock tick to avoid inundating remote processor * with interrupts if open failed */ if (status < 0) { Task_sleep(1); } } while (status < 0); System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self()); /* Register the Client Delegate with the RM Client Instance */ rmTransportCfg.rmHandle = rmClientHandle; rmTransportCfg.appTransportHandle = (Rm_AppTransportHandle) clientToCdQId; rmTransportCfg.remoteInstType = Rm_instType_CLIENT_DELEGATE; rmTransportCfg.remoteInstName = &rmClientDelegateName[0]; /* Set the callouts as valid for the first transport configuration on Client instance */ rmTransportCfg.transportCalloutsValid = true; rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc; rmTransportCfg.transportCallouts.rmSendPkt = transportSend; clientCdHandle = Rm_transportRegister(&rmTransportCfg, &result); /* Store the mapping information in the transport map */ rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle = clientCdHandle; rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ; System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self()); } /* Create the RM receive task. */ System_printf("Core %d: Creating RM receive task...\n", MultiProc_self()); Task_Params_init (&taskParams); testReceiveTskHandle = Task_create (testReceiveTsk, &taskParams, NULL); /* Create the RM test task. */ System_printf("Core %d: Creating RM test task...\n", MultiProc_self()); Task_Params_init (&taskParams); testRmTskHandle = Task_create (testRmTsk, &taskParams, NULL); } /* * ======== main ======== * Synchronizes all processors (in Ipc_start) and calls BIOS_start */ Int main(Int argc, Char* argv[]) { Rm_InitCfg rmInitCfg; Task_Params taskParams; FILE *globalResourceFp; FILE *linuxDtbFp; FILE *globalPolicyFp; FILE *staticPolicyFp; Int globalResourceFileSize; Int linuxDtbFileSize; Int globalPolicyFileSize; Int staticPolicyFileSize; void *globalResourceList = NULL; void *linuxDtb = NULL; void *globalPolicy = NULL; void *staticPolicy = NULL; Int status; Int readSize; Rm_ServiceReqInfo requestInfo; int32_t result; System_printf ("*********************************************************\n"); System_printf ("********************** RM Testing ***********************\n"); System_printf ("*********************************************************\n"); System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr()); /* Initialize the RM instances - RM must be initialized before anything else in the system * Core 0: 1 RM Instance - RM Server * Core 1: 2 RM Instances - RM Client Delegate * RM Client */ if (MultiProc_self()== 0) { initSyncObj(); globalResourceFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\global-resources.dtb", "rb"); linuxDtbFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\linux-evm.dtb", "rb"); globalPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\server-policy.dtb", "rb"); fseek(globalResourceFp, 0, SEEK_END); globalResourceFileSize = ftell(globalResourceFp); rewind(globalResourceFp); fseek(linuxDtbFp, 0, SEEK_END); linuxDtbFileSize = ftell(linuxDtbFp); rewind(linuxDtbFp); fseek(globalPolicyFp, 0, SEEK_END); globalPolicyFileSize = ftell(globalPolicyFp); rewind(globalPolicyFp); globalResourceList = Osal_rmMalloc(globalResourceFileSize); linuxDtb = Osal_rmMalloc(linuxDtbFileSize); globalPolicy = Osal_rmMalloc(globalPolicyFileSize); readSize = fread(globalResourceList, 1, globalResourceFileSize, globalResourceFp); System_printf("Read Size compared to file size: %d : %d\n", readSize, globalResourceFileSize); readSize = fread(linuxDtb, 1, linuxDtbFileSize, linuxDtbFp); System_printf("Read Size compared to file size: %d : %d\n", readSize, linuxDtbFileSize); readSize = fread(globalPolicy, 1, globalPolicyFileSize, globalPolicyFp); System_printf("Read Size compared to file size: %d : %d\n", readSize, globalPolicyFileSize); /* Create the Server instance */ rmInitCfg.instName = &rmServerName[0]; rmInitCfg.instType = Rm_instType_SERVER; rmInitCfg.instCfg.serverCfg.globalResourceList = globalResourceList; rmInitCfg.instCfg.serverCfg.linuxDtb = linuxDtb; rmInitCfg.instCfg.serverCfg.globalPolicy = globalPolicy; rmServerHandle = Rm_init(&rmInitCfg, &result); System_printf("Core %d: RM Server instance created. Result = %d\n", MultiProc_self(), result); Rm_printResourceStatus(rmServerHandle); } else if (MultiProc_self()== 1) { staticPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\test\\dts_files\\static-policy.dtb", "rb"); fseek(staticPolicyFp, 0, SEEK_END); staticPolicyFileSize = ftell(staticPolicyFp); rewind(staticPolicyFp); staticPolicy = Osal_rmMalloc(staticPolicyFileSize); readSize = fread(staticPolicy, 1, staticPolicyFileSize, staticPolicyFp); System_printf("Read Size compared to file size: %d : %d\n", readSize, staticPolicyFileSize); /* Create the RM Client Delegate instance */ rmInitCfg.instName = &rmClientDelegateName[0]; rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE; rmInitCfg.instCfg.cdCfg.staticPolicy = staticPolicy; rmClientDelegateHandle = Rm_init(&rmInitCfg, &result); System_printf("Core %d: RM Client Delegate instance created. Result = %d\n", MultiProc_self(), result); /* Create the RM Client instance */ rmInitCfg.instName = &rmClientName[0]; rmInitCfg.instType = Rm_instType_CLIENT; rmInitCfg.instCfg.clientCfg.staticPolicy = staticPolicy; rmClientHandle = Rm_init(&rmInitCfg, &result); System_printf("Core %d: RM Client instance created. Result = %d\n", MultiProc_self(), result); /* Open service handles on the CD and Client to test static allocations */ rmClientDelegateServiceHandle = Rm_serviceOpenHandle(rmClientDelegateHandle, &result); rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result); /* Static allocations */ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameQosCluster; requestInfo.resourceBase = 0; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName); rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo); if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) { System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(), rmClientDelegateName, resourceNameQosCluster, responseInfo.resourceBase, responseInfo.resourceLength); } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameQosCluster; requestInfo.resourceBase = 2; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) { System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(), rmClientName, resourceNameQosCluster, responseInfo.resourceBase, responseInfo.resourceLength); } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Next request should return error */ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameQosCluster; requestInfo.resourceBase = 1; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) { System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(), rmClientName, resourceNameQosCluster, responseInfo.resourceBase, responseInfo.resourceLength); } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } /* Allocated shared resource to both CD and Client using static policy */ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameAifQ; requestInfo.resourceBase = 525; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientDelegateName); rmClientDelegateServiceHandle->Rm_serviceHandler(rmClientDelegateServiceHandle->rmHandle, &requestInfo, &responseInfo); if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) { System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(), rmClientDelegateName, resourceNameAifQ, responseInfo.resourceBase, responseInfo.resourceLength); } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo)); memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo)); requestInfo.type = Rm_service_RESOURCE_ALLOCATE_INIT; requestInfo.resourceName = resourceNameAifQ; requestInfo.resourceBase = 525; requestInfo.resourceLength = 1; requestInfo.callback.serviceCallback = testServiceCallback; System_printf("Core %d: %s allocating static resource...\n", MultiProc_self(), rmClientName); rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo); if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) { System_printf("Core %d: %s got %s: base: %d length: %d\n", MultiProc_self(), rmClientName, resourceNameAifQ, responseInfo.resourceBase, responseInfo.resourceLength); } else { System_printf("Core %d: Static allocation failed with error: %d\n", MultiProc_self(), responseInfo.serviceState); } } System_printf("Core %d: Starting IPC...\n", MultiProc_self()); status = Ipc_start(); if (status < 0) { System_abort("Ipc_start failed\n"); } /* Create the RM startup task */ System_printf("Core %d: Creating RM startup task...\n", MultiProc_self()); Task_Params_init (&taskParams); startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL); System_printf("Core %d: Starting BIOS...\n", MultiProc_self()); BIOS_start(); return (0); }