diff --git a/test/rm_test.c b/test/rm_test.c
index 855986c2d67b475debf77db11dd009c3c1ea9d7a..1e12b99028e5358825727c23b042b32a8fe472d9 100644 (file)
--- a/test/rm_test.c
+++ b/test/rm_test.c
-/*
- * Copyright (c) 2012, Texas Instruments Incorporated
+/*
+ * rm_test.c
+ *
+ * Multicore Resource Manager test that uses IPC to an application
+ * requesting RM services from a RM Server, Client Delegate, and Client.
+ *
+ * ============================================================================
+ *
+ * Copyright (c) 2012-2013, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* 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
- *
- * This is an example program that uses MessageQ to pass a message
- * from one processor to another.
- *
- * Each processor creates its own MessageQ first and then will try to open
- * a remote processor's MessageQ.
*
- * See message_multicore.k file for expected output.
*/
-
-#include <c6x.h>
-#include <xdc/std.h>
-#include <stdio.h>
+
+/* Standard Includes */
#include <string.h>
#include <stdbool.h>
-/* -----------------------------------XDC.RUNTIME module Headers */
+/* XDC Includes */
+#include <xdc/std.h>
#include <xdc/runtime/System.h>
-#include <xdc/runtime/IHeap.h>
-/* ----------------------------------- IPC module Headers */
+/* IPC Includes */
#include <ti/ipc/Ipc.h>
#include <ti/ipc/MessageQ.h>
#include <ti/ipc/HeapBufMP.h>
#include <ti/ipc/MultiProc.h>
+#include <ti/ipc/GateMP.h>
-/* ----------------------------------- BIOS6 module Headers */
+/* BIOS Includes */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
+#include <ti/sysbios/family/c64p/Hwi.h>
-/* ----------------------------------- Resource Manager Headers */
+/* CSL Includes */
+#include <ti/csl/csl_semAux.h>
+#include <ti/csl/csl_cacheAux.h>
+#include <ti/csl/csl_xmcAux.h>
+
+/* RM Includes */
#include <ti/drv/rm/rm.h>
-#include <ti/drv/rm/rm_osal.h>
#include <ti/drv/rm/rm_transport.h>
#include <ti/drv/rm/rm_services.h>
-/* ======== Task Handles ======== */
-Task_Handle startupRmTskHandle;
-
-/* ======== 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_INSTANCE_NAME_MAX_CHARS] = "RM_Server";
-Char rmClientDelegateName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client_Delegate";
-Char rmClientName[RM_INSTANCE_NAME_MAX_CHARS] = "RM_Client";
-
-/* ======== RM IPC MessageQ Names ======== */
-Char serverCdQueueName[30] = "RM_Server_CD_Queue";
-Char cdServerQueueName[30] = "RM_CD_Server_Queue";
-Char cdClientQueueName[30] = "RM_CD_Client_Queue";
-Char clientCdQueueName[30] = "RM_Client_CD_Queue";
-
-/* ======== RM Instance Handles ======== */
-Rm_Handle rmServerHandle = NULL;
-Rm_Handle rmClientDelegateHandle = NULL;
-Rm_Handle rmClientHandle = NULL;
+/**********************************************************************
+ ************************** RM Test Symbols ***************************
+ **********************************************************************/
+
+/* IPC MessageQ heap name */
+#define MSGQ_HEAP_NAME "msgQHeapBuf"
+/* IPC MessageQ heap ID */
+#define MSGQ_HEAP_ID 0
+
+/* RM packet heap name */
+#define RM_PKT_HEAP_NAME "rmHeapBuf"
+/* Name of GateMP used to synchronize the RM test tasks */
+#define RM_TASK_GATE_NAME "rmGateMP"
+
+/* Application's core 0 registered RM transport indices */
+#define SERVER_TO_CD_MAP_ENTRY 0
+/* Application's core 1 registered RM transport indices */
+#define CD_TO_SERVER_MAP_ENTRY 0
+#define CD_TO_CLIENT_MAP_ENTRY 1
+#define CLIENT_TO_CD_MAP_ENTRY 2
+/* Maximum number of registered RM transports */
+#define MAX_MAPPING_ENTRIES 3
+
+/* Size of RM static allocation response queue. Must be greater than number of APPROVED
+ * static allocations */
+#define MAX_STATIC_ALLOCATION_RESPS 5
+
+/* Size of RM service response queue */
+#define MAX_QUEUED_SERVICE_RESPONSES 10
+
+/* Error checking macro */
+#define ERROR_CHECK(checkVal, resultVal, rmInstName, printMsg) \
+ if (resultVal != checkVal) { \
+ char errorMsgToPrint[] = printMsg; \
+ System_printf("Error Core %d : %s : ", coreNum, rmInstName); \
+ System_printf("%s with error code : %d\n", errorMsgToPrint, resultVal); \
+ System_abort("Test Failure\n"); \
+ }
-/* ======== RM Instance Service Ports ======== */
-Rm_ServicePort *rmServerServicePort = NULL;
-Rm_ServicePort *rmClientDelegateServicePort = NULL;
-Rm_ServicePort *rmClientServicePort = NULL;
+/**********************************************************************
+ ********************** RM Test Data Structures ***********************
+ **********************************************************************/
-/* ======== RM Transport Packet Definition ======== */
+/* IPC MessageQ RM packet encapsulation structure */
typedef struct {
- MessageQ_MsgHeader msgQHeader;
- /* Pointer to packet provided by RM */
- Rm_Packet *rmPkt;
+ /* IPC MessageQ header (must be first element in structure) */
+ MessageQ_MsgHeader msgQHeader;
+ /* Pointer to RM packet */
+ 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
-
+/* RM registered transport mapping structure */
typedef struct {
+ /* Registered RM transport handle */
Rm_TransportHandle transportHandle;
- MessageQ_Handle receiveMsgQ;
- MessageQ_QueueId remoteMsgQId;
+ /* MessageQ receive queue tied to the transport handle */
+ 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];
-
-/* ======== RM Application Transport APIs ======== */
+/**********************************************************************
+ ********************** Extern Variables ******************************
+ **********************************************************************/
+
+/* RM test Global Resource List (GRL) */
+extern const char rmGrl[];
+/* Example Linux DTB file provided to RM Server for automatic Linux Kernel resource extraction */
+extern const char rmLinuxDtb[];
+/* RM test Global Policy provided to RM Server */
+extern const char rmGlobalPolicy[];
+/* RM test Static Policy provided to RM Client Delegate and Client */
+extern const char rmStaticPolicy[];
+
+/* OSAL RM Local Gate Initialization. */
+extern void Osal_rmLocalGateInit (void);
+
+/**********************************************************************
+ ********************** Global Variables ******************************
+ **********************************************************************/
+
+/* DSP core number according to IPC */
+uint16_t coreNum;
+
+/* Task to configure application transport code for RM */
+Task_Handle rmStartupTskHandle;
+/* High priority task for receiving RM packets */
+Task_Handle rmReceiveTskHandle;
+/* RM server test task */
+Task_Handle rmServerTskHandle;
+/* RM client delegate and client test task */
+Task_Handle rmClientTskHandle;
+
+/* GateMP used to synchronize tests between the two RM test tasks */
+GateMP_Handle gateHandle = NULL;
+/* GateMP key */
+IArg gateKey;
+
+/* Handle for heap that RM packets will be allocated from */
+HeapBufMP_Handle rmPktHeapHandle = NULL;
+
+/* MessageQ used by RM CD to send packets to RM Server */
+char serverFromCdQueueName[30] = "RM_Server_From_CD_Queue";
+/* MessageQ used by RM Server to send packets to RM CD */
+char cdFromServerQueueName[30] = "RM_CD_From_Server_Queue";
+/* MessageQ used by RM Client to send packets to RM CD */
+char cdFromClientQueueName[30] = "RM_CD_From_Client_Queue";
+/* MessageQ used by RM CD to send packets to RM Client */
+char clientFromCdQueueName[30] = "RM_Client_From_CD_Queue";
+
+/* RM Server instance name (must match with RM Global Resource List (GRL) and policies */
+char rmServerName[RM_NAME_MAX_CHARS] = "RM_Server";
+/* RM CD instance name (must match with RM Global Resource List (GRL) and policies */
+char rmCdName[RM_NAME_MAX_CHARS] = "RM_Client_Delegate";
+/* RM Client instance name (must match with RM Global Resource List (GRL) and policies */
+char rmClientName[RM_NAME_MAX_CHARS] = "RM_Client";
+
+/* RM instance handles */
+Rm_Handle rmServerHandle = NULL;
+Rm_Handle rmCdHandle = NULL;
+Rm_Handle rmClientHandle = NULL;
+
+/* RM instance service handles */
+Rm_ServiceHandle *rmServerServiceHandle = NULL;
+Rm_ServiceHandle *rmCdServiceHandle = NULL;
+Rm_ServiceHandle *rmClientServiceHandle = NULL;
+
+/* Transport map stores the RM transport handle to IPC MessageQ queue mapping */
+Transport_MapEntry rmTransportMap[MAX_MAPPING_ENTRIES];
+
+/* Static allocation response queue */
+Rm_ServiceRespInfo staticResponseQueue[MAX_STATIC_ALLOCATION_RESPS];
+/* Static allocation response queue index */
+uint32_t numStaticResponses;
+
+
+/* RM response info queue used to store service responses received via the callback function */
+Rm_ServiceRespInfo responseInfoQueue[MAX_QUEUED_SERVICE_RESPONSES];
+
+/* RM resource names (must match resource node names in GRL and policies */
+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 resourceNameInfraQ[RM_NAME_MAX_CHARS] = "infra-queue";
+
+/* Test RM NameServer name */
+char nameServerNameFavQ[RM_NAME_MAX_CHARS] = "My_Favorite_Queue";
+
+/**********************************************************************
+ *************************** Test Functions ***************************
+ **********************************************************************/
+
+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);
+}
-Rm_Packet *TransportAlloc (Rm_TransportHandle transportHandle, uint32_t pktSize)
+void endMemAccess (void *ptr, uint32_t size)
{
- Rm_Packet *pkt = NULL;
+ 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);
+}
- /* All transports will allocate from the same heap */
-
- HeapBufMP_alloc(rmPktHeapHandle, pktSize, 0);
+Rm_Packet *transportAlloc(Rm_AppTransportHandle appTransport, uint32_t pktSize, Rm_PacketHandle *pktHandle)
+{
+ Rm_Packet *rmPkt = NULL;
+ MsgQ_RmPacket *rmMsg = NULL;
- if (pkt != NULL)
- {
- pkt->pktLenBytes = pktSize;
+ /* 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", coreNum);
+ *pktHandle = NULL;
+ return(NULL);
}
-
- return (pkt);
+ 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);
}
-int32_t TransportFree (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
+void transportFree (MessageQ_Msg rmMsgQMsg, Rm_Packet *pkt)
{
uint32_t pktSize = pkt->pktLenBytes;
+ int32_t status;
- /* All transports will free to the same heap */
-
+ /* All transports will free rmPkts to the same heap */
HeapBufMP_free(rmPktHeapHandle, pkt, pktSize);
- return (0);
+ status = MessageQ_free(rmMsgQMsg);
+ if (status < 0) {
+ System_printf("Core %d: MessageQ_free had a failure/error in transportFree\n", coreNum);
+ }
}
-int32_t TransportSend (Rm_TransportHandle transportHandle, Rm_Packet *pkt)
+int32_t transportSend (Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle)
{
- MsgQ_RmPacket *rmMsg = NULL;
- MessageQ_QueueId remoteQueueId;
- bool handleValid = false;
- int32_t status, i;
-
- /* Get the remoteQueueId based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the remoteQueueId associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- remoteQueueId = rmTransportMap[i].remoteMsgQId;
- /* Break out of the search loop */
- handleValid = true;
- break;
- }
+ 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", coreNum,
+ status);
}
+ return (status);
+}
- if (handleValid)
- {
- /* 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());
+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", coreNum);
}
- /* Attach the RM packet to the MessageQ message */
- rmMsg->rmPkt = pkt;
- /* Send the message to the remote side */
- status = MessageQ_put(remoteQueueId, (MessageQ_Msg)rmMsg);
- if (status < 0)
- {
- System_printf("Core %d: MessageQ_put had a failure/error in TransportSend\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", coreNum, status);
}
+
+ /* Free RM packet buffer and messageQ message */
+ transportFree(rmMsg, rmPkt);
}
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportSend couldn't find transportHandle in transport map\n", MultiProc_self());
- status = -1;
- }
-
- return (status);
}
-void * TransportReceive (Rm_TransportHandle transportHandle)
+void serviceCallback(Rm_ServiceRespInfo *serviceResponse)
{
- MessageQ_Handle receiveQ;
- MessageQ_Msg rmMsg = NULL;
- Rm_Packet *rmPkt = NULL;
- bool queueValid = false;
- int32_t status, i;
-
- /* Get the receiveQ based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the receiveQ associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- receiveQ = rmTransportMap[i].receiveMsgQ;
- /* Break out of the search loop */
- queueValid = true;
- break;
+ uint32_t qIndex = 0;
+
+ /* Populate next free entry in the responseInfoQueue */
+ while (responseInfoQueue[qIndex].serviceId != 0) {
+ qIndex++;
+ if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
+ qIndex = 0;
}
}
- if (queueValid)
- {
- /* Get the next message from the receiveQ */
- status = (int32_t) MessageQ_get(receiveQ, &rmMsg, MessageQ_FOREVER);
- if (status < 0)
- {
- System_abort("This should not happen since timeout is forever\n");
+ /* Save the response in the response queue for the test task to pick up */
+ memcpy((void *)&responseInfoQueue[qIndex], (void *)serviceResponse, sizeof(Rm_ServiceRespInfo));
+}
+
+bool waitForResponse(Rm_ServiceRespInfo *respInfo)
+{
+ uint32_t qIndex = 0;
+
+ if (respInfo->serviceState == RM_SERVICE_PROCESSING) {
+ /* Scan responseInfoQueue for the response received via the callback function */
+ while((responseInfoQueue[qIndex].serviceId != respInfo->serviceId) ||
+ (responseInfoQueue[qIndex].rmHandle != respInfo->rmHandle)) {
+ qIndex++;
+ if (qIndex == MAX_QUEUED_SERVICE_RESPONSES) {
+ qIndex = 0;
+ }
+
+ /* Higher priority receive task will retrieve response */
+ }
+
+ memcpy((void *)respInfo, (void *)&responseInfoQueue[qIndex], sizeof(Rm_ServiceRespInfo));
+ memset((void *)&responseInfoQueue[qIndex], 0, sizeof(Rm_ServiceRespInfo));
+ }
+ return(TRUE);
+}
+
+void setRmRequest(Rm_ServiceReqInfo *reqInfo, Rm_ServiceType type, const char *resName, int32_t resBase,
+ uint32_t resLen, int32_t resAlign, const char *nsName, bool setCallback, Rm_ServiceRespInfo *respInfo)
+{
+ memset((void *)reqInfo, 0, sizeof(Rm_ServiceReqInfo));
+ reqInfo->type = type;
+ reqInfo->resourceName = resName;
+ reqInfo->resourceBase = resBase;
+ reqInfo->resourceLength = resLen;
+ reqInfo->resourceAlignment = resAlign;
+ reqInfo->resourceNsName = nsName;
+ if (setCallback) {
+ reqInfo->callback.serviceCallback = serviceCallback;
+ }
+ memset((void *)respInfo, 0, sizeof(Rm_ServiceRespInfo));
+}
+
+void rmCleanupTsk(UArg arg0, UArg arg1)
+{
+ int32_t result;
+
+ /* Delete the RM test tasks */
+ System_printf("Core %d: Deleting RM startup task...\n", coreNum);
+ if (rmStartupTskHandle) {
+ Task_delete(&rmStartupTskHandle);
+ /* Set the task handle to be NULL so that the delete only occurs once */
+ rmStartupTskHandle = NULL;
+ }
+
+ if (coreNum == 0) {
+ if (rmServerTskHandle) {
+ System_printf("Core %d: Deleting RM server task...\n", coreNum);
+ Task_delete(&rmServerTskHandle);
+ /* Set the task handle to be NULL so that the delete only occurs once */
+ rmServerTskHandle = NULL;
}
- if (rmMsg == NULL)
- {
- System_printf("Core %d: MessageQ_get failed returning a null packet in TransportReceive\n", MultiProc_self());
+ }
+ else if (coreNum == 1) {
+ if (rmClientTskHandle) {
+ System_printf("Core %d: Deleting RM client task...\n", coreNum);
+ Task_delete(&rmClientTskHandle);
+ /* Set the task handle to be NULL so that the delete only occurs once */
+ rmClientTskHandle = NULL;
}
+ }
+
+ /* Delete the RM receive task */
+ System_printf("Core %d: Deleting RM receive task...\n", coreNum);
+ if (rmReceiveTskHandle) {
+ Task_delete(&rmReceiveTskHandle);
+ /* Set the task handle to be NULL so that the delete only occurs once */
+ rmReceiveTskHandle = NULL;
+ }
- /* Extract the Rm_Packet from the RM msg */
- rmPkt = ((MsgQ_RmPacket *)rmMsg)->rmPkt;
+ /* Cleanup all service ports, transport handles, RM instances, and IPC constructs */
+ if (coreNum == 0) {
+ Rm_serviceCloseHandle(rmServerServiceHandle);
- /* Free the messageQ message now that RM packet pointer has been extracted */
- status = MessageQ_free(rmMsg);
- if (status < 0)
- {
- System_printf("Core %d: MessageQ_free had a failure/error in TransportReceive\n", MultiProc_self());
- }
+ Rm_transportUnregister(rmTransportMap[SERVER_TO_CD_MAP_ENTRY].transportHandle);
+
+ result = Rm_delete(rmServerHandle, true);
+ if (result != RM_OK) {
+ System_printf("Core %d: RM server instance delete failed with error %d\n", coreNum, result);
+ }
}
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportReceive couldn't find transportHandle in transport map\n", MultiProc_self());
+ else if (coreNum == 1) {
+ Rm_serviceCloseHandle(rmCdServiceHandle);
+ Rm_serviceCloseHandle(rmClientServiceHandle);
+
+ Rm_transportUnregister(rmTransportMap[CD_TO_SERVER_MAP_ENTRY].transportHandle);
+ Rm_transportUnregister(rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].transportHandle);
+ Rm_transportUnregister(rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].transportHandle);
+
+ result = Rm_delete(rmCdHandle, true);
+ if (result != RM_OK) {
+ System_printf("Core %d: RM cd instance delete failed with error %d\n", coreNum, result);
+ }
+ result = Rm_delete(rmClientHandle, true);
+ if (result != RM_OK) {
+ System_printf("Core %d: RM client instance delete failed with error %d\n", coreNum, result);
+ }
}
- /* Pass the RM packet back to RM */
- return ((void *)rmPkt);
+ BIOS_exit(0);
}
-int32_t TransportNumPktsReceived (Rm_TransportHandle transportHandle)
+/* Receive task has priority of 2 so that it pre-empts the RM instance test tasks */
+void rmReceiveTsk(UArg arg0, UArg arg1)
{
- MessageQ_Handle receiveQ;
- bool queueValid = false;
- int32_t numPkts, i;
-
- /* Get the receiveQ based on the transportHandle */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
- /* transportHandle found in mapping table. Get the receiveQ associated
- * with it */
- if (rmTransportMap[i].transportHandle == transportHandle)
- {
- receiveQ = rmTransportMap[i].receiveMsgQ;
- /* Break out of the search loop */
- queueValid = true;
- break;
+ while(1) {
+ if (coreNum == 0) {
+ transportReceive(SERVER_TO_CD_MAP_ENTRY);
+ }
+ else if (coreNum == 1) {
+ transportReceive(CD_TO_SERVER_MAP_ENTRY);
+ transportReceive(CD_TO_CLIENT_MAP_ENTRY);
+ transportReceive(CLIENT_TO_CD_MAP_ENTRY);
}
+ /* Sleep for 1ms so that the main test tasks can run */
+ Task_sleep(1);
}
+}
- if (queueValid)
- {
- /* Get the number of messages in the receiveQ */
- numPkts = (int32_t) MessageQ_count(receiveQ);
+void rmServerTsk(UArg arg0, UArg arg1)
+{
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
+ Task_Params taskParams;
+
+ Rm_printInstanceStatus(rmServerHandle);
+
+ /* BEGIN testing UNSPECIFIED base and alignment requests on Server */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
+ RM_RESOURCE_BASE_UNSPECIFIED, 1, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length %d alignment : ", coreNum,
+ rmServerName,
+ resourceNameGpQ,
+ requestInfo.resourceLength,
+ requestInfo.resourceAlignment);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
+ RM_RESOURCE_BASE_UNSPECIFIED, 1, RM_RESOURCE_ALIGNMENT_UNSPECIFIED, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length UNSPECIFIED alignment : ", coreNum,
+ rmServerName,
+ resourceNameGpQ,
+ requestInfo.resourceLength);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
+ RM_RESOURCE_BASE_UNSPECIFIED, 1, 200, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length %d alignment : ", coreNum,
+ rmServerName,
+ resourceNameGpQ,
+ requestInfo.resourceLength,
+ requestInfo.resourceAlignment);
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ /* END testing UNSPECIFIED base and alignment requests on Server */
+
+ /* Create new NameServer object */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_MAP_TO_NAME, resourceNameGpQ,
+ 1002, 1, 0, nameServerNameFavQ, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s create name %s tied to %s %d - %d : ", coreNum,
+ rmServerName,
+ nameServerNameFavQ,
+ responseInfo.resourceName,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Wait for CD and Client retrieve resource via name, allocate the resource, free resource via name, and
+ * delete the NameServer object. */
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
+
+ /* Try to allocate the memory region taken by the Linux Kernel and not specified as shared */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameMemRegion,
+ 12, 1, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameMemRegion,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState != RM_SERVICE_APPROVED) {
+ System_printf("PASSED : denial or error : %d\n", responseInfo.serviceState);
}
- else
- {
- /* Could not find a registered transport handle that matched the handle provided by RM.
- * Return an error to RM. */
- System_printf("Core %d: TransportNumPktsReceived couldn't find transportHandle in transport map\n", MultiProc_self());
- numPkts = -1;
+ else {
+ System_printf("FAILED\n");
+ }
+
+ /* BEGIN testing expansion/contraction of resource nodes with the AIF RX CH resource */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
+ 14, 5, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
}
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
- return (numPkts);
-}
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
+ 19, 31, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Wait for Client and Client Delegate to do their allocations */
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifRxCh,
+ 25, 3, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s free of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifRxCh,
+ 34, 3, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s free of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, resourceNameAifRxCh,
+ 28, 6, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s free of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
+ 53, 2, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ /* END testing expansion/contraction of resource nodes with the AIF RX CH resource */
+
+ /* Test execlusive rights to an allocated resource */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
+ 2, 2, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState != RM_SERVICE_APPROVED) {
+ System_printf("PASSED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ else {
+ System_printf("FAILED\n");
+ }
+
+ /* Wait for Client and Client Delegate to do their UNSPECIFIED allocates */
+ gateKey = GateMP_enter(gateHandle);
+ GateMP_leave(gateHandle, gateKey);
+
+ /* 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 */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ,
+ 6543, 10, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameGpQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameGpQ,
+ 6543, 10, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameGpQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Allocate infrastructure queue taken by Linux kernel and shared with Rm_Client. Expect error or denial. */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameInfraQ,
+ 805, 1, 0, NULL, TRUE, &responseInfo);
+ rmServerServiceHandle->Rm_serviceHandler(rmServerServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation of %s %d - %d : ", coreNum,
+ rmServerName,
+ resourceNameInfraQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState != RM_SERVICE_APPROVED) {
+ System_printf("PASSED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ else {
+ System_printf("FAILED\n");
+ }
-/*
- * ======== testServiceCallback ========
- * Application's callback function given to RM on service requests
- */
-Void testServiceCallback(Rm_ServiceRespInfo *serviceResponse)
-{
+ System_printf("Core %d: Testing is complete\n", coreNum);
+ Rm_printInstanceStatus(rmServerHandle);
+ Rm_printResourceStatus(rmServerHandle);
+
+ /* Create the RM cleanup task. */
+ System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
+ Task_Params_init (&taskParams);
+ Task_create (rmCleanupTsk, &taskParams, NULL);
}
-/*
- * ======== testRmTsk ========
- * RM test task
- */
-Void testRmTsk(UArg arg0, UArg arg1)
+void rmClientTsk(UArg arg0, UArg arg1)
{
- Rm_ServiceReqInfo requestInfo;
- Rm_ServiceRespInfo responseInfo;
-
- /* 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)
- {
- rmServerServicePort = Rm_getServicePort(rmServerHandle);
- }
- else if (MultiProc_self() == 1)
- {
- rmClientDelegateServicePort = Rm_getServicePort(rmClientDelegateHandle);
- rmClientServicePort = Rm_getServicePort(rmClientHandle);
- }
-
- memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
- memset((void *)&responseInfo, 0, sizeof(Rm_ServiceRespInfo));
-
- /* Use the service ports to test the service requests */
- if (MultiProc_self() == 0)
- {
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "hw_semaphore";
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "dsp_core_lock";
-
- /* TEMP: Try mapping a resource in Name Server */
- requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
- requestInfo.resourceName = &resourceName[0];
- requestInfo.resourceBase = 1;
- requestInfo.resourceRange = 2;
- requestInfo.resourceNsName = &resourceNsName[0];
- requestInfo.callback.serviceCallback = testServiceCallback;
-
- /* Issue the service request via the service port */
- rmServerServicePort->rmService(rmServerServicePort->rmHandle, &requestInfo, &responseInfo);
- }
- else if (MultiProc_self() == 1)
- {
- char resourceName[RM_RESOURCE_NAME_MAX_CHARS] = "timer";
- char resourceNsName[RM_RESOURCE_NAME_MAX_CHARS] = "dsp_timer";
-
- /* TEMP: Try mapping a resource in Name Server from Client to test transports */
- requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
- requestInfo.resourceName = &resourceName[0];
- requestInfo.resourceBase = 2;
- requestInfo.resourceRange = 3;
- requestInfo.resourceNsName = &resourceNsName[0];
- requestInfo.callback.serviceCallback = testServiceCallback;
-
- /* Issue the service request via the service port */
- rmClientServicePort->rmService(rmClientServicePort->rmHandle, &requestInfo, &responseInfo);
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
+ Task_Params taskParams;
+ uint32_t i, j;
+
+ Rm_printInstanceStatus(rmCdHandle);
+ Rm_printInstanceStatus(rmClientHandle);
+
+ /* Retrieve a resource via a NameServer name */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_GET_BY_NAME, NULL,
+ 0, 0, 0, nameServerNameFavQ, TRUE, &responseInfo);
+ rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s get resource with name %s : ", coreNum,
+ rmCdName,
+ nameServerNameFavQ);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Allocate the resource returned from the NameServer request */
+ memset((void *)&requestInfo, 0, sizeof(Rm_ServiceReqInfo));
+ 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 = serviceCallback;
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ responseInfo.resourceName,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Free resource via a NameServer name */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_FREE, NULL,
+ 0, 0, 0, nameServerNameFavQ, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s free resource with name %s : ", coreNum,
+ rmClientName,
+ nameServerNameFavQ);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Delete the NameServer name */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_UNMAP_NAME, NULL,
+ 0, 0, 0, nameServerNameFavQ, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s delete name %s : ", coreNum,
+ rmClientName,
+ nameServerNameFavQ);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ GateMP_leave(gateHandle, gateKey);
+ gateKey = GateMP_enter(gateHandle);
+
+ /* BEGIN testing expansion/contraction of resource nodes with the AIF RX CH resource */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAifRxCh,
+ 0, 6, 0, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifRxCh,
+ 50, 7, 0, NULL, TRUE, &responseInfo);
+ rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation of %s %d - %d : ", coreNum,
+ rmCdName,
+ resourceNameAifRxCh,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ /* END testing expansion/contraction of resource nodes with the AIF RX CH resource */
+
+ GateMP_leave(gateHandle, gateKey);
+ gateKey = GateMP_enter(gateHandle);
+
+ /* BEGIN testing allocations with UNSPECIFIED base and alignment values */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
+ RM_RESOURCE_BASE_UNSPECIFIED, 5, 4, NULL, TRUE, &responseInfo);
+ rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length %d alignment : ", coreNum,
+ rmCdName,
+ resourceNameAccumCh,
+ requestInfo.resourceLength,
+ requestInfo.resourceAlignment);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
}
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
+ RM_RESOURCE_BASE_UNSPECIFIED, 2, 1, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length %d alignment : ", coreNum,
+ rmClientName,
+ resourceNameAccumCh,
+ requestInfo.resourceLength,
+ requestInfo.resourceAlignment);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_USE, resourceNameAccumCh,
+ RM_RESOURCE_BASE_UNSPECIFIED, 2, RM_RESOURCE_ALIGNMENT_UNSPECIFIED, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s use allocation of %s UNSPECIFIED base %d length UNSPECIFIED alignment : ", coreNum,
+ rmClientName,
+ resourceNameAccumCh,
+ requestInfo.resourceLength);
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ /* END testing allocations with UNSPECIFIED base and alignment values */
+
+ /* Allocate infrastructure queue shared between Linux kernel and Client */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameInfraQ,
+ 800, 1, 0, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameInfraQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Allocate a resource without providing a callback function. RM should block and not return until the result
+ * is returned by the server. */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameGpQ,
+ 7000, 1, 0, NULL, FALSE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s init allocation (without callback specified) of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameGpQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_PROCESSING) {
+ waitForResponse(&responseInfo);
+ }
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ GateMP_leave(gateHandle, gateKey);
+
+ /* Verify static allocations were validated. Validation responses should have been received after the
+ * first service requests were made on the Client and CD post transport path registration. */
+ while (numStaticResponses > 0) {
+ /* Loop until all static request validations have been received */
+ for (i = 0; i < MAX_STATIC_ALLOCATION_RESPS; i++) {
+ if (staticResponseQueue[i].serviceId != 0) {
+ for (j = 0; j < MAX_QUEUED_SERVICE_RESPONSES; j++) {
+ if ((staticResponseQueue[i].serviceId == responseInfoQueue[j].serviceId) &&
+ (staticResponseQueue[i].rmHandle == responseInfoQueue[j].rmHandle)) {
+ System_printf("Core %d : static allocation validation of %s %d - %d : ", coreNum,
+ responseInfoQueue[j].resourceName,
+ responseInfoQueue[j].resourceBase,
+ (responseInfoQueue[j].resourceBase + responseInfoQueue[j].resourceLength - 1));
+ if (responseInfoQueue[j].serviceState == RM_SERVICE_APPROVED) {
+ System_printf("PASSED\n");
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfoQueue[j].serviceState);
+ }
+ memset((void *)&staticResponseQueue[i], 0, sizeof(Rm_ServiceRespInfo));
+ memset((void *)&responseInfoQueue[j], 0, sizeof(Rm_ServiceRespInfo));
+ numStaticResponses--;
+ break;
+ }
+ }
+ }
+ }
+ }
- System_printf("The test is complete\n");
- BIOS_exit(0);
+
+ System_printf("Core %d: Testing is complete\n", coreNum);
+
+ Rm_printInstanceStatus(rmCdHandle);
+ Rm_printInstanceStatus(rmClientHandle);
+
+ /* Create the RM cleanup task. */
+ System_printf("Core %d: Creating RM cleanup task...\n", coreNum);
+ Task_Params_init (&taskParams);
+ Task_create (rmCleanupTsk, &taskParams, NULL);
}
-/*
- * ======== startupRmTsk ========
- * Configures application transports and registers them with RM
- */
-Void startupRmTsk(UArg arg0, UArg arg1)
+void rmStartupTsk(UArg arg0, UArg arg1)
{
- MessageQ_Handle serverCdMsgQ, cdServerMsgQ, cdClientMsgQ, clientCdMsgQ;
- MessageQ_QueueId serverCdQId, cdServerQId, cdClientQId, clientCdQId;
- Int status, i;
- HeapBufMP_Handle msgQHeapHandle;
- HeapBufMP_Params heapBufParams;
- Rm_TransportCfg rmTransportCfg;
+ MessageQ_Handle serverFromCdMsgQ, cdFromServerMsgQ, cdFromClientMsgQ, clientFromCdMsgQ;
+ MessageQ_QueueId serverToCdQId, cdToServerQId, cdToClientQId, clientToCdQId;
+ Int status, i;
+ GateMP_Params gateParams;
+ HeapBufMP_Handle msgQHeapHandle;
+ HeapBufMP_Params heapBufParams;
+ Rm_TransportCfg rmTransportCfg;
+ int32_t result = 0;
Rm_TransportHandle serverCdHandle, cdServerHandle, cdClientHandle, clientCdHandle;
- Task_Params taskParams;
+ Task_Params taskParams;
/* Initialize the transport map */
- for (i = 0; i < MAX_MAPPING_ENTRIES; i++)
- {
+ for (i = 0; i < MAX_MAPPING_ENTRIES; i++) {
rmTransportMap[i].transportHandle = NULL;
}
- if (MultiProc_self() == 0)
- {
+ /* Create the gate internal to RM for service requests not specifying a callback function
+ * and needing a blocking operation to complete.
+ *
+ * Must be created from a different task than the test tasks to allow proper blocking. */
+ Osal_rmLocalGateInit();
+
+ if (coreNum == 0) {
+ GateMP_Params_init(&gateParams);
+ gateParams.name = RM_TASK_GATE_NAME;
+ gateHandle = GateMP_create(&gateParams);
+
/* 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. */
heapBufParams.numBlocks = 64;
heapBufParams.blockSize = sizeof(Rm_Packet);
rmPktHeapHandle = HeapBufMP_create(&heapBufParams);
- if (rmPktHeapHandle == NULL)
- {
+ if (rmPktHeapHandle == NULL) {
System_abort("HeapBufMP_create failed for RM packet heap\n" );
}
- System_printf("Core %d: RM packet heap created\n", MultiProc_self());
+ System_printf("Core %d: RM packet heap created\n", coreNum);
/* Create the heap that will be used to allocate messageQ messages. */
HeapBufMP_Params_init(&heapBufParams);
heapBufParams.numBlocks = 64;
heapBufParams.blockSize = sizeof(MsgQ_RmPacket);
msgQHeapHandle = HeapBufMP_create(&heapBufParams);
- if (msgQHeapHandle == NULL)
- {
+ if (msgQHeapHandle == NULL) {
System_abort("HeapBufMP_create failed MessageQ message heap\n" );
}
- System_printf("Core %d: IPC MessageQ message heap created\n", MultiProc_self());
+ System_printf("Core %d: IPC MessageQ message heap created\n", coreNum);
}
- else
- {
+ else {
+ do {
+ status = GateMP_open(RM_TASK_GATE_NAME, &gateHandle);
+ /*
+ * Sleep for 1 clock tick to avoid inundating remote processor
+ * with interrupts if open failed
+ */
+ if (status < 0) {
+ Task_sleep(1);
+ }
+ } while (status < 0);
+ /* Take the gate right away to prepare for RM testing */
+ gateKey = GateMP_enter(gateHandle);
+
/* Open the heaps created by the other processor. Loop until opened. */
- do
- {
+ 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)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: RM packet heap opened\n", MultiProc_self());
+ System_printf("Core %d: RM packet heap opened\n", coreNum);
- do
- {
+ 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)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: IPC MessageQ message heap opened\n", MultiProc_self());
+ System_printf("Core %d: IPC MessageQ message heap opened\n", coreNum);
}
/* Register the MessageQ heap with MessageQ */
- MessageQ_registerHeap((IHeap_Handle)msgQHeapHandle, MSGQ_HEAP_ID);
+ MessageQ_registerHeap(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 queue on RM Server
+ * 1 queues on RM Server
* 2 queues on RM Client Delegate
- * 1 queue on RM Client */
- if (MultiProc_self() == 0)
- {
- /* Create the RM Server messageQ used by the RM Client Delegate */
- serverCdMsgQ = MessageQ_create(serverCdQueueName, NULL);
- if (serverCdMsgQ == NULL)
- {
+ * 1 queues on RM Client */
+ if (coreNum == 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());
+ System_printf("Core %d: RM Server MessageQ created for receiving packets from RM CD\n", coreNum);
}
- else if (MultiProc_self() == 1)
- {
- /* Create the RM Client Delegate messageQ used by the RM Server */
- cdServerMsgQ = MessageQ_create(cdServerQueueName, NULL);
- if (cdServerMsgQ == NULL)
- {
+ else if (coreNum == 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());
- /* Create the RM Client Delegate messageQ used by the RM Client */
- cdClientMsgQ = MessageQ_create(cdClientQueueName, NULL);
- if (cdClientMsgQ == NULL)
- {
+ System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Server\n", coreNum);
+
+ 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());
- /* Create the RM Client messageQ used by the RM Client Delegate */
- clientCdMsgQ = MessageQ_create(clientCdQueueName, NULL);
- if (clientCdMsgQ == NULL)
+ System_printf("Core %d: RM CD MessageQ created for receiving packets from RM Client\n", coreNum);
+
+ 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());
+ System_printf("Core %d: RM Client MessageQ created for receiving packets from RM CD\n", coreNum);
}
/* Open the remote message queues. Also register the RM transports with each RM instance */
- if (MultiProc_self() == 0)
- {
+ if (coreNum == 0) {
/* Open the Client Delegate messageQ from the Server */
- do
- {
- status = MessageQ_open(cdServerQueueName, &serverCdQId);
+ do {
+ status = MessageQ_open(cdFromServerQueueName, &serverToCdQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: RM CD MessageQ opened from RM Server\n", MultiProc_self());
+ System_printf("Core %d: RM CD MessageQ opened from RM Server\n", coreNum);
/* 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];
- rmTransportCfg.transportCalloutsValid = true;
- rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
- rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
- rmTransportCfg.transportCallouts.rmSend = TransportSend;
- rmTransportCfg.transportCallouts.rmReceive = TransportReceive;
- rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived;
-
- serverCdHandle = Rm_transportRegister(rmServerHandle, &rmTransportCfg);
+ rmTransportCfg.remoteInstName = &rmCdName[0];
+ 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 = serverCdMsgQ;
- rmTransportMap[SERVER_TO_CD_MAP_ENTRY].remoteMsgQId = serverCdQId;
- System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", MultiProc_self());
-
+ rmTransportMap[SERVER_TO_CD_MAP_ENTRY].receiveMsgQ = serverFromCdMsgQ;
+ System_printf("Core %d: Registered RM Server <=> RM CD transport with RM Server instance\n", coreNum);
}
- else if (MultiProc_self() == 1)
- {
+ else if (coreNum == 1) {
/* Open the Server messageQ from the Client Delegate */
- do
- {
- status = MessageQ_open(serverCdQueueName, &cdServerQId);
+ do {
+ status = MessageQ_open(serverFromCdQueueName, &cdToServerQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: RM Server MessageQ opened from RM CD\n", MultiProc_self());
+ System_printf("Core %d: RM Server MessageQ opened from RM CD\n", coreNum);
/* Register the Server with the RM Client Delegate Instance */
+ rmTransportCfg.rmHandle = rmCdHandle;
+ 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 this core */
- rmTransportCfg.transportCalloutsValid = true;
- rmTransportCfg.transportCallouts.rmAllocPkt = TransportAlloc;
- rmTransportCfg.transportCallouts.rmFreePkt = TransportFree;
- rmTransportCfg.transportCallouts.rmSend = TransportSend;
- rmTransportCfg.transportCallouts.rmReceive = TransportReceive;
- rmTransportCfg.transportCallouts.rmNumPktsReceived = TransportNumPktsReceived;
-
- cdServerHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
+ 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 = cdServerMsgQ;
- rmTransportMap[CD_TO_SERVER_MAP_ENTRY].remoteMsgQId = cdServerQId;
- System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", MultiProc_self());
+ rmTransportMap[CD_TO_SERVER_MAP_ENTRY].receiveMsgQ = cdFromServerMsgQ;
+ System_printf("Core %d: Registered RM CD <=> RM Server transport with RM CD instance\n", coreNum);
/* Open the Client messageQ from the Client Delegate */
- do
- {
- status = MessageQ_open(clientCdQueueName, &cdClientQId);
+ do {
+ status = MessageQ_open(clientFromCdQueueName, &cdToClientQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: RM Client MessageQ opened from RM CD\n", MultiProc_self());
+ System_printf("Core %d: RM Client MessageQ opened from RM CD\n", coreNum);
/* 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 so set them as invalid */
- rmTransportCfg.transportCalloutsValid = false;
-
- cdClientHandle = Rm_transportRegister(rmClientDelegateHandle, &rmTransportCfg);
+ rmTransportCfg.transportCallouts.rmAllocPkt = transportAlloc;
+ rmTransportCfg.transportCallouts.rmSendPkt = transportSend;
+ 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 = cdClientMsgQ;
- rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].remoteMsgQId = cdClientQId;
- System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", MultiProc_self());
-
+ rmTransportMap[CD_TO_CLIENT_MAP_ENTRY].receiveMsgQ = cdFromClientMsgQ;
+ System_printf("Core %d: Registered RM CD <=> RM Client transport with RM CD instance\n", coreNum);
+
/* Open the Client Delegate messageQ from the Client */
- do
- {
- status = MessageQ_open(cdClientQueueName, &clientCdQId);
+ do {
+ status = MessageQ_open(cdFromClientQueueName, &clientToCdQId);
/*
* Sleep for 1 clock tick to avoid inundating remote processor
* with interrupts if open failed
*/
- if (status < 0)
- {
+ if (status < 0) {
Task_sleep(1);
}
} while (status < 0);
- System_printf("Core %d: RM CD MessageQ opened from RM Client\n", MultiProc_self());
+ System_printf("Core %d: RM CD MessageQ opened from RM Client\n", coreNum);
/* 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];
- /* Callouts already set so set them as invalid */
- rmTransportCfg.transportCalloutsValid = false;
-
- clientCdHandle = Rm_transportRegister(rmClientHandle, &rmTransportCfg);
+ rmTransportCfg.remoteInstName = &rmCdName[0];
+ 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 = clientCdMsgQ;
- rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].remoteMsgQId = clientCdQId;
- System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", MultiProc_self());
+ rmTransportMap[CLIENT_TO_CD_MAP_ENTRY].receiveMsgQ = clientFromCdMsgQ;
+ System_printf("Core %d: Registered RM Client <=> RM CD transport with RM Client instance\n", coreNum);
}
-
- /* Create the RM test task. */
- System_printf("Core %d: Creating RM test task...\n", MultiProc_self());
+
+ /* Create the RM receive task. Assign higher priority than the test tasks so that
+ * when they spin waiting for messages from other RM instances the receive task is
+ * executed. */
+ System_printf("Core %d: Creating RM receive task...\n", coreNum);
Task_Params_init (&taskParams);
- Task_create (testRmTsk, &taskParams, NULL);
+ taskParams.priority = 2;
+ rmReceiveTskHandle = Task_create (rmReceiveTsk, &taskParams, NULL);
+
+ /* Create the RM test tasks. */
+ if (coreNum == 0) {
+ System_printf("Core %d: Creating RM server task...\n", coreNum);
+ Task_Params_init (&taskParams);
+ taskParams.priority = 1;
+ rmServerTskHandle = Task_create (rmServerTsk, &taskParams, NULL);
+ }
+ else if (coreNum) {
+ System_printf("Core %d: Creating RM client task...\n", coreNum);
+ Task_Params_init (&taskParams);
+ taskParams.priority = 1;
+ rmClientTskHandle = Task_create (rmClientTsk, &taskParams, NULL);
+ }
}
-/*
- * ======== main ========
- * Synchronizes all processors (in Ipc_start) and calls BIOS_start
- */
-Int main(Int argc, Char* argv[])
+int main(Int argc, Char* argv[])
{
- Rm_InitCfg rmInitCfg;
- Task_Params taskParams;
- FILE *globalResourceFp;
- FILE *linuxDtbFp;
- FILE *globalPolicyFp;
- Int globalResourceFileSize;
- Int linuxDtbFileSize;
- Int globalPolicyFileSize;
- void *globalResourceList = NULL;
- void *linuxDtb = NULL;
- void *globalPolicy = NULL;
- Int status;
- Int readSize;
+ Rm_InitCfg rmInitCfg;
+ Task_Params taskParams;
+ int status;
+ Rm_ServiceReqInfo requestInfo;
+ Rm_ServiceRespInfo responseInfo;
+ int32_t result;
System_printf ("*********************************************************\n");
System_printf ("********************** RM Testing ***********************\n");
System_printf ("RM Version : 0x%08x\nVersion String: %s\n", Rm_getVersion(), Rm_getVersionStr());
+ coreNum = MultiProc_self();
+
/* Initialize the RM instances - RM must be initialized before anything else in the system
- * Core 0: 1 RM Instance - RM Server
+ * Core 0: 1 RM Instance - RM Server
* Core 1: 2 RM Instances - RM Client Delegate
* RM Client
*/
- if (MultiProc_self()== 0)
- {
- /* Open the Global Resource and Policy DTB files */
- globalResourceFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\tci6614-global-resources.dtb", "rb");
- linuxDtbFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\tci6614-linux-evm.dtb", "rb");
- globalPolicyFp = fopen("C:\\ti\\pdk_tci6614_1_0_0_11\\packages\\ti\\drv\\rm\\device\\global-policy.dtb", "rb");
-
- /* Get the size of the Global Resource List, Linux DTB, and Global Policy */
- 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);
-
- /* Allocate buffers to hold the Global Resource List, Linux DTB, and Global Policy */
- globalResourceList = Osal_rmMalloc(globalResourceFileSize);
- linuxDtb = Osal_rmMalloc(linuxDtbFileSize);
- globalPolicy = Osal_rmMalloc(globalPolicyFileSize);
-
- /* Read the file data into the allocated buffers */
- 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);
-
- System_printf("Core %d: RM Server instance created\n", MultiProc_self());
-
- /* Create the RM Server instance */
- rmInitCfg.instName = &rmServerName[0];
+ if (coreNum == 0) {
+ /* Create the Server instance */
+ rmInitCfg.instName = rmServerName;
rmInitCfg.instType = Rm_instType_SERVER;
- /* Provide the DTBs to the RM Server */
- rmInitCfg.globalResourceList = globalResourceList;
- rmInitCfg.linuxDtb = linuxDtb;
- rmInitCfg.startupPolicy = globalPolicy;
-
- /* Get the RM Server handle */
- rmServerHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Server instance created\n", MultiProc_self());
+ rmInitCfg.instCfg.serverCfg.globalResourceList = (void *)rmGrl;
+ rmInitCfg.instCfg.serverCfg.linuxDtb = (void *)rmLinuxDtb;
+ rmInitCfg.instCfg.serverCfg.globalPolicy = (void *)rmGlobalPolicy;
+ rmServerHandle = Rm_init(&rmInitCfg, &result);
+ ERROR_CHECK(RM_OK, result, rmServerName, "Initialization failed");
+
+ /* Open Server service handle */
+ rmServerServiceHandle = Rm_serviceOpenHandle(rmServerHandle, &result);
+ ERROR_CHECK(RM_OK, result, rmServerName, "Service handle open failed");
}
- else if (MultiProc_self()== 1)
- {
+ else if (coreNum == 1) {
/* Create the RM Client Delegate instance */
- rmInitCfg.instName = &rmClientDelegateName[0];
+ rmInitCfg.instName = rmCdName;
rmInitCfg.instType = Rm_instType_CLIENT_DELEGATE;
- /* SET TO NULL - FEATURES NOT ADDED YET */
- rmInitCfg.globalResourceList = NULL;
- rmInitCfg.startupPolicy = NULL;
+ rmInitCfg.instCfg.cdCfg.staticPolicy = (void *)rmStaticPolicy;
+ rmCdHandle = Rm_init(&rmInitCfg, &result);
+ ERROR_CHECK(RM_OK, result, rmCdName, "Initialization failed");
- /* Get the RM Client Delegate handle */
- rmClientDelegateHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Client Delegate instance created\n", MultiProc_self());
+ /* Open CD service handle */
+ rmCdServiceHandle = Rm_serviceOpenHandle(rmCdHandle, &result);
+ ERROR_CHECK(RM_OK, result, rmCdName, "Service handle open failed");
/* Create the RM Client instance */
rmInitCfg.instName = &rmClientName[0];
- rmInitCfg.instType = Rm_instType_CLIENT;
- /* SET TO NULL - FEATURES NOT ADDED YET */
- rmInitCfg.globalResourceList = NULL;
- rmInitCfg.startupPolicy = NULL;
+ rmInitCfg.instType = Rm_instType_CLIENT;
+ rmInitCfg.instCfg.clientCfg.staticPolicy = (void *)rmStaticPolicy;
+ rmClientHandle = Rm_init(&rmInitCfg, &result);
+ ERROR_CHECK(RM_OK, result, rmClientName, "Initialization failed");
+
+ /* Open Client service handle */
+ rmClientServiceHandle = Rm_serviceOpenHandle(rmClientHandle, &result);
+ ERROR_CHECK(RM_OK, result, rmClientName, "Service handle open failed");
+
+ /* Initialize the static allocation response queue */
+ for (numStaticResponses = 0; numStaticResponses < MAX_STATIC_ALLOCATION_RESPS; numStaticResponses++) {
+ memset((void *)&staticResponseQueue[numStaticResponses], 0, sizeof(Rm_ServiceRespInfo));
+ }
+ numStaticResponses = 0;
+
+ /* Static allocation tests */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
+ 0, 1, 0, NULL, TRUE, &responseInfo);
+ rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s static init allocation of %s %d - %d : ", coreNum,
+ rmCdName,
+ resourceNameQosCluster,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("PASSED\n");
+ memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(Rm_ServiceRespInfo));
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
+ 2, 1, 0, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s static init allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameQosCluster,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("PASSED\n");
+ memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(Rm_ServiceRespInfo));
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
+
+ /* Request resource from Client that can only be allocated to CD according to static policy */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameQosCluster,
+ 1, 1, 0, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s static init allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameQosCluster,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState != RM_SERVICE_APPROVED_STATIC) {
+ System_printf("PASSED : denial or error : %d\n", responseInfo.serviceState);
+ }
+ else {
+ System_printf("FAILED\n");
+ }
+
+ /* Request resource from both Client and CD that is shared according to static policy */
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifQ,
+ 525, 1, 0, NULL, TRUE, &responseInfo);
+ rmCdServiceHandle->Rm_serviceHandler(rmCdServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s static init allocation of %s %d - %d : ", coreNum,
+ rmCdName,
+ resourceNameAifQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("PASSED\n");
+ memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(Rm_ServiceRespInfo));
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
- /* Get the RM Client handle */
- rmClientHandle = Rm_init(&rmInitCfg);
- System_printf("Core %d: RM Client instance created\n", MultiProc_self());
+ setRmRequest(&requestInfo, Rm_service_RESOURCE_ALLOCATE_INIT, resourceNameAifQ,
+ 525, 1, 0, NULL, TRUE, &responseInfo);
+ rmClientServiceHandle->Rm_serviceHandler(rmClientServiceHandle->rmHandle, &requestInfo, &responseInfo);
+ System_printf("Core %d : %s static init allocation of %s %d - %d : ", coreNum,
+ rmClientName,
+ resourceNameAifQ,
+ requestInfo.resourceBase,
+ (requestInfo.resourceBase + requestInfo.resourceLength - 1));
+ if (responseInfo.serviceState == RM_SERVICE_APPROVED_STATIC) {
+ System_printf("PASSED\n");
+ memcpy((void *)&staticResponseQueue[numStaticResponses++], (void *)&responseInfo, sizeof(Rm_ServiceRespInfo));
+ }
+ else {
+ System_printf("FAILED : denial or error : %d\n", responseInfo.serviceState);
+ }
}
- /*
- * Ipc_start() calls Ipc_attach() to synchronize all remote processors
- * because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
- */
- System_printf("Core %d: Starting IPC...\n", MultiProc_self());
+ System_printf("Core %d: Starting IPC...\n", coreNum);
status = Ipc_start();
- if (status < 0)
- {
+ 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());
+ System_printf("Core %d: Creating RM startup task...\n", coreNum);
Task_Params_init (&taskParams);
- startupRmTskHandle = Task_create (startupRmTsk, &taskParams, NULL);
+ rmStartupTskHandle = Task_create (rmStartupTsk, &taskParams, NULL);
- System_printf("Core %d: Starting BIOS...\n", MultiProc_self());
+ System_printf("Core %d: Starting BIOS...\n", coreNum);
BIOS_start();
return (0);