/*
 *  ======== MpuRcmServerTest ========
 */
Int MpuRcmServerTest (Int testCase)
{
    Int status = 0;

    Osal_printf ("MpuRcmServerTest: Testing RCM server on MPU\n");

    status = ipcSetup1 (testCase);
    if (status < 0) {
        Osal_printf ("MpuRcmServerTest: ipcSetup failed, status [0x%x]\n");
        goto exit;
    }

    StartRcmServerTestThread (testCase);

    /* Wait until signaled to delete the rcm server */
    Osal_printf ("MpuRcmServerTest: Wait for server thread completion.\n");
    sem_wait (&mainThreadWait);

    pthread_join (thread, NULL);

    status = RcmServerCleanup (testCase);
    if (status < 0)
        Osal_printf ("MpuRcmServerTest: Error in RcmServerCleanup \n");

exit:
    Osal_printf ("MpuRcmServerTest: Leaving MpuRcmServerTest()\n");
    return status;
}
/*!
 *  @brief      Function to unmap
 *
 *
 *  @param      mappedAddr       The remote address to unmap
 *  @param      procId                 The remote Processor ID
 *
 *  @sa         SysLinkMemUtils_map
 */
Int
SysLinkMemUtils_unmap (UInt32 mappedAddr, ProcMgr_ProcId procId)
{
    ProcMgr_Handle procMgrHandle;
    Int32          status = PROCMGR_SUCCESS;

    /* Open a handle to the ProcMgr instance. */
    if (procId == PROC_APPM3) {
        procId = PROC_SYSM3;
    }

    /* Open a handle to the ProcMgr instance. */
    status = ProcMgr_open (&procMgrHandle, procId);
    if (status < 0) {
        Osal_printf ("Error in ProcMgr_open [0x%x]\n", status);
    }
    else {
        status = ProcMgr_unmap (procMgrHandle, mappedAddr, procId);
        /* FIX ME: Add Proc unreserve call */
        if (status < 0) {
            Osal_printf ("Error in ProcMgr_unmap [0x%x]\n", status);
        }
        else {
            status = ProcMgr_close (&procMgrHandle);
        }
    }

    return status;
}
/*!
 *  @brief      Function to retrieve physical entries given a remote
 *              Processor's virtual address.
 *
 *              This function returns success state of this function
 *
 *  @param      remoteAddr  The slave's address
 *  @param      size        size of buffer
 *  @param      physEntries Translated physical addresses of each Page.
 *  @param      procId      Remote Processor Id.
 *  @param      flags       Used to pass any custom information for optimization.
 *
 *  @sa         SysLinkMemUtils_virtToPhys
 */
Int
SysLinkMemUtils_virtToPhysPages (UInt32         remoteAddr,
                                 UInt32         numOfPages,
                                 UInt32         physEntries[],
                                 ProcMgr_ProcId procId)
{
    Int             i;
    Int32           status = PROCMGR_SUCCESS;
    ProcMgr_Handle  procMgrHandle;

    GT_1trace (curTrace, GT_ENTER, "SysLinkMemUtils_virtToPhys: remote Addr",
                    remoteAddr);

    if (physEntries == NULL || (numOfPages == 0)) {
        Osal_printf("SysLinkMemUtils_virtToPhys: ERROR:Input arguments invalid:"
                    "physEntries = 0x%x, numOfPages = %d\n",
                    (UInt32)physEntries, numOfPages);
        return PROCMGR_E_FAIL;
    }

    if (procId == PROC_APPM3) {
        procId = PROC_SYSM3;
    }

    Osal_printf ("testing with ProcMgr_virtToPhysPages\n");

    /* Open a handle to the ProcMgr instance. */
    status = ProcMgr_open (&procMgrHandle, procId);
    if (status < 0) {
        Osal_printf ("Error in ProcMgr_open [0x%x]\n", status);
        return PROCMGR_E_FAIL;
    }
    /* TODO: Hack for tiler */
    if(remoteAddr >= TILER_ADDRESS_START && remoteAddr < TILER_ADDRESS_END) {
        for (i = 0; i < numOfPages; i++) {
            physEntries[i] = Page_ALIGN_LOW(remoteAddr, Page_SIZE_4K) + \
                                                                    (4096 * i);
        }
    }
    else {
        status = ProcMgr_virtToPhysPages (procMgrHandle, remoteAddr,
                    numOfPages, physEntries, procId);
    }

    if (status < 0) {
        Osal_printf ("Error in ProcMgr_virtToPhysPages [0x%x]\n", status);
    }
    else {
        for (i = 0; i < numOfPages; i++) {
            Osal_printf("physEntries[%d] = 0x%x\n", i, physEntries[i]);
        }
    }

    status = ProcMgr_close (&procMgrHandle);

    return status;
}
/** print usage and exit */
static Void printUsageExit (Char * app)
{
    Osal_printf ("%s: [-h] [-l logfile] [-f]\n", app);
    Osal_printf ("  -h   Show this help message.\n");
    Osal_printf ("  -l   Select log file to write. (\"stdout\" can be used for"
                 "terminal output.)\n");
    Osal_printf ("  -f   Run in foreground. (Do not fork daemon process.)\n");

    exit (EXIT_SUCCESS);
}
/** ============================================================================
 *  Functions
 *  ============================================================================
 */
Void printUsage (Void)
{
    Osal_printf ("Usage: ./slpmresources.out [<TestNo>]\n");
    Osal_printf ("\tValid Values:\n\t\tTestNo: 1 or 2 (default = 1)\n");
    Osal_printf ("\tExamples:\n");
    Osal_printf ("\t\t./slpmresources.out 1: MessageQ sample with SysM3\n");
    Osal_printf ("\t\t./slpmresources.out 2: MessageQ sample with AppM3\n");

    return;
}
/*!
 *  @brief  Linux driver function to finalize the driver module.
 */
static
void __exit SyslinkMemMgrDrv_finalizeModule (void)
{
    Osal_printf ("Entered SyslinkMemMgrDrv_finalizeModule\n");

    SyslinkMemMgrDrv_unregisterDriver (&(SyslinkMemMgrDrv_osalDrvHandle));

    /* Finalize the OsalDriver */
    OsalDriver_destroy ();

    Osal_printf ("Leaving SyslinkMemMgrDrv_finalizeModule\n");
}
Example #7
0
/*!
 *  @brief  Linux driver function to finalize the driver module.
 */
static
void __exit NameServerDrv_finalizeModule (void)
{
    Osal_printf ("Entered NameServerDrv_finalizeModule\n");

    NameServerDrv_unregisterDriver (&(NameServerDrv_osalDrvHandle));

    /* Finalize the OsalDriver */
    OsalDriver_destroy ();

    Osal_printf ("Leaving NameServerDrv_finalizeModule\n");
}
Example #8
0
/*
 *  ======== signal_handler ========
 */
static Void signal_handler (Int sig)
{
    pthread_t self = pthread_self ();
    if (pthread_equal (self, sysM3EvtHandlerThrd)) {
        Osal_printf ("\n** SysLink Daemon: SysM3 thread exiting...\n ");
    }
    else if (pthread_equal (self, appM3EvtHandlerThrd)) {
        Osal_printf ("\n** SysLink Daemon: AppM3 thread exiting...\n ");
    }
    else {
        Osal_printf ("\n** SysLink Daemon: Exiting due to KILL command...\n");
        sem_post (&semDaemonWait);
    }
}
/*!
 *  @brief      Function to Map Host processor to Remote processors
 *              module
 *
 *              This function can be called by the application to map their
 *              address space to remote slave's address space.
 *
 *  @param      MpuAddr
 *
 *  @sa         SysLinkMemUtils_unmap
 */
Int
SysLinkMemUtils_map (SyslinkMemUtils_MpuAddrToMap   mpuAddrList [],
                     UInt32                         numOfBuffers,
                     UInt32 *                       mappedAddr,
                     ProcMgr_MapType                memType,
                     ProcMgr_ProcId                 procId)
{
    ProcMgr_Handle  procMgrHandle;
    UInt32          mappedSize;
    Int32           status = PROCMGR_SUCCESS;

    if (numOfBuffers > 1) {
        status = PROCMGR_E_INVALIDARG;
        Osal_printf ("SysLinkMemUtils_map numBufError [0x%x]\n", status);
        return status;
    }

    if (procId == PROC_APPM3) {
        procId = PROC_SYSM3;
    }

    if (memType == ProcMgr_MapType_Tiler) {
        /* TILER addresses are pre-mapped, so just return the TILER ssPtr */
        *mappedAddr = TilerMem_VirtToPhys ((Void *)mpuAddrList [0].mpuAddr);
        return status;
    }

    /* Open a handle to the ProcMgr instance. */
    status = ProcMgr_open (&procMgrHandle, procId);
    if (status < 0) {
        Osal_printf ("Error in ProcMgr_open [0x%x]\n", status);
    }
    else {
        /* FIX ME: Add Proc reserve call */
        status = ProcMgr_map (procMgrHandle, (UInt32)mpuAddrList [0].mpuAddr,
                        (UInt32)mpuAddrList [0].size, mappedAddr, &mappedSize,
                        memType, procId);
         /* FIX ME: Add the table that keeps the C-D translations */
        if (status < 0) {
            Osal_printf ("Error in ProcMgr_map [0x%x]\n", status);
        }
        else {
            status = ProcMgr_close (&procMgrHandle);
        }
    }

    return status;
}
Example #10
0
/*
 *  ======== sysM3EventHandler ========
 */
static Void sysM3EventHandler (Void)
{
    Int                 status  = PROCMGR_E_FAIL;
    UInt                index;
    Int                 size;
    ProcMgr_EventType   eventList [] = {PROC_MMU_FAULT, PROC_ERROR,
                                                    PROC_WATCHDOG};

    size = (sizeof (eventList)) / (sizeof (ProcMgr_EventType));
    status = ProcMgr_waitForMultipleEvents (PROC_SYSM3, eventList, size, -1,
                                            &index);
    if (status == PROCMGR_SUCCESS) {
        if (eventList [index] == PROC_MMU_FAULT) {
            Osal_printf ("\nMMU Fault occured on the M3 subsystem. See crash "
                         "dump for more details...\n");
        }
        else if (eventList [index] == PROC_ERROR) {
            Osal_printf ("\nSysError occured on SysM3. See crash dump for more "
                         "details...\n");
        }
        else {
            Osal_printf ("\nWatchDog fired on the M3 subsystem.\n");
        }

        if ((eventList [index] == PROC_MMU_FAULT) ||
            (eventList [index] == PROC_ERROR)) {
            /* Dump Crash Info */
            exceptionDumpRegisters ();
        }

        /* Initiate cleanup */
        isSysM3Event = TRUE;
        restart = TRUE;
        sem_post (&semDaemonWait);
    }
    else {
        if (errno == EINTR) {
            Osal_printf ("SysM3 Event Handler Thread %s\n", strerror(errno));
        }
        else {
            Osal_printf ("SysM3 Event Handler Thread block failed 0x%x\n",
                status);
            isSysM3Event = TRUE;
            /* Post the semaphore to terminate the parent process */
            sem_post (&semDaemonWait);
        }
    }
}
/*!
 *  @brief  Function to execute the startup for loader sample application
 *
 *  @sa
 */
Int loader_startup (Void)
{
    Int i;
    Int status = 0;

    for (i = 0; i < loader_numProcessors; i++) {
        Osal_printf ("Loading and starting procId [%d] with [%s]\n",
                    loader_procId[i] ,
                    loader_filePath[i] );
        status = ProcMgrApp_startup (loader_procId[i],
                                    loader_filePath[i]);
        Osal_printf ("ProcMgrApp_startup status [%d]\n", status);
    }

    return (status);
}
int main (int argc, char ** argv)
{
    Int status             = 0;
    //ServiceMgr_Config serviceMgrConfig;

    Int i, j;

    /*
     *  Must be at least one set of procId and outfile. So argc cannot be odd
     */
    if ((argc < 3) || (argc / 2 * 2 == argc) || (argc > 7)) {
        Osal_printf ("uiaDemo <procId> <outfile> [<procId> <outfile>] [<procId> <outfile>]\n");
        return (-1);
    }

    for (i = 0, j = 1 ; i < argc/2; i++, j = j + 2) {
        uiaDemo_procId[i] = strtol (argv [j], NULL, 16);
        uiaDemo_filePath[i] = argv [j + 1];
        uiaDemo_numProcessors++;
    }

    Osal_printf ("Running on %d processors\n", uiaDemo_numProcessors);

    Osal_printf ("Calling SysLink_setup\n");
    SysLink_setup ();

    Osal_printf ("Calling uiaDemo_startup\n");
    status = uiaDemo_startup ();

    /* write to a binary file instead of sending out over Ethernet */
    //ServiceMgr_getConfig (&serviceMgrConfig);
    //strcpy(serviceMgrConfig.fileName, "eventDump");
    //status = ServiceMgr_setConfig (&serviceMgrConfig);
    //Osal_printf ("ServiceMgr_setConfig status = [0x%x]\n", status);

    Osal_printf ("Calling ServiceMgr_start\n");
    ServiceMgr_start();

    Osal_printf ("Calling uiaDemo_execute\n");
    status = uiaDemo_execute ();

    Osal_printf ("Calling ServiceMgr_stop\n");
    ServiceMgr_stop();

    Osal_printf ("Calling uiaDemo_shutdown\n");
    status = uiaDemo_shutdown ();

    Osal_printf ("Calling SysLink_destroy\n");
    SysLink_destroy ();

    return (0);
}
/*!
 *  @brief  Function to execute the shutdown for loader sample application
 *
 *  @sa
 */
Int loader_shutdown (Void)
{
    Int i;
    Int status = 0;

    for (i = 0; i < loader_numProcessors; i++) {
        status = Notify_sendEvent(loader_procId[i], 0, SHUTDOWN, 0, FALSE);
        Osal_printf ("Notify_sendEvent status [%d]\n", status);
    }

    for (i = 0; i < loader_numProcessors; i++) {
        /* shutdown the logic one by one for each processor */
        status = ProcMgrApp_shutdown(loader_procId[i]);
        Osal_printf ("ProcMgrApp_shutdown status [%d]\n", status);
    }

    return (status);
}
Example #14
0
/*
 *  ======== fxnExit ========
 */
Int32 fxnExit (UInt32 dataSize, UInt32 *data)
{
    Int status = 0;

    Osal_printf ("Executing Remote Function fxnExit \n");

    sem_post (&serverThreadSync);

    return status;
}
Int loader_execute (Void)
{
    Int status = 0;
    Char ch;

    Osal_printf ("\nOpen DVT and start getting events! [hit enter to shutdown the demo]\n");
    ch = getchar();

    return (status);
}
Example #16
0
/*
 *  ======== RunServerTestThread ========
 *     RCM server test thread function
 */
Void StartRcmServerTestThread (Int testCase)
{
    sem_init (&mainThreadWait, 0, 0);

    /* Create the server thread */
    Osal_printf ("StartRcmServerThread: Create server thread.\n");
    pthread_create (&thread, NULL, (Void *)&RcmServerThreadFxn,
                    (Void *) testCase);

    return;
}
Example #17
0
/*
 *  ======== TestExec ========
 */
Int TestExec (Void)
{
    Int                  status             = 0;
    Int                  loop;
    RcmClient_Message  * rcmMsg             = NULL;
    RcmClient_Message  * returnMsg          = NULL;
    UInt                 rcmMsgSize;
    RCM_Remote_FxnArgs * fxnDoubleArgs;

    Osal_printf ("\nTestExec: Testing exec API\n");

    for (loop = 1; loop <= LOOP_COUNT; loop++) {
        /* Allocate a remote command message */
        rcmMsgSize = sizeof(RCM_Remote_FxnArgs);

        Osal_printf ("TestExec: calling RcmClient_alloc \n");
        rcmMsg = NULL;
        status = RcmClient_alloc (rcmClientHandle, rcmMsgSize, &rcmMsg);
        if (status < 0) {
            Osal_printf ("TestExec: Error allocating RCM message\n");
            goto exit;
        }

        /* Fill in the remote command message */
        rcmMsg->fxnIdx = fxnDoubleIdx;
        fxnDoubleArgs = (RCM_Remote_FxnArgs *)(&rcmMsg->data);
        fxnDoubleArgs->a = loop;

        /* Execute the remote command message */
        Osal_printf ("TestExec: calling RcmClient_exec \n");
        status = RcmClient_exec (rcmClientHandle, rcmMsg, &returnMsg);
        if (status < 0) {
            Osal_printf ("TestExec: RcmClient_exec error, status = "
                         "[0x%x].\n", status);
            goto exit;
        }

        fxnDoubleArgs = (RCM_Remote_FxnArgs *)(&(returnMsg->data));
        Osal_printf ("TestExec: called fxnDouble(%d)), result = %d\n",
            fxnDoubleArgs->a, returnMsg->result);

        /* Return message to the heap */
        Osal_printf ("TestExec: calling RcmClient_free \n");
        RcmClient_free (rcmClientHandle, returnMsg);
        returnMsg = NULL;
    }

exit:
    Osal_printf ("TestExec: Leaving TestExec()\n");
    return status;
}
Example #18
0
/*
 *  ======== GetSymbolIndex ========
 */
Int GetSymbolIndex (Void)
{
    Int status = 0;

    /* Get remote function index */
    Osal_printf ("\nGetSymbolIndex: Querying server for fxnDouble() function "
                 "index \n");
    status = RcmClient_getSymbolIndex (rcmClientHandle, "fxnDouble",
                                        &fxnDoubleIdx);
    if (status < 0)
        Osal_printf ("GetSymbolIndex: Error getting fxnDouble symbol index"
                     "[0x%x]\n", status);
    else
        Osal_printf ("GetSymbolIndex: fxnDouble() symbol index [0x%x]\n",
                        fxnDoubleIdx);

    Osal_printf ("GetSymbolIndex: Querying server for fxnExit() function "
                 "index \n");
    status = RcmClient_getSymbolIndex (rcmClientHandle, "fxnExit", &fxnExitIdx);
    if (status < 0)
        Osal_printf ("GetSymbolIndex: Error getting fxnExit symbol index"
                     " [0x%x]\n", status);
    else
        Osal_printf ("GetSymbolIndex: fxnExit() symbol index [0x%x]\n",
                        fxnExitIdx);

    return status;
}
/*
 *  ======== main ========
 */
Int main (Int argc, Char * argv [])
{
    Int status      = 0;
    Int testNo;
    Int subTestNo;

    Osal_printf ("\n== RCM Client or Server Sample ==\n");

    if (argc < 3) {
        printUsage ();
        goto exit;
    }

    testNo = atoi (argv[1]);
    subTestNo = atoi (argv[2]);
    if ((testNo < 1 || testNo > 3) || (subTestNo != 1 && subTestNo != 2)) {
        printUsage ();
        goto exit;
    }

    /* Run RCM client test */
    if(subTestNo == 1) {
        Osal_printf ("RCM Client sample invoked\n");
        status = MpuRcmClientTest (testNo);
        if (status < 0) {
            Osal_printf ("Error in RCM Client sample\n");
        }
    }

    /* Run RCM server test */
    if(subTestNo == 2) {
        Osal_printf ("RCM Server sample invoked\n");
        status = MpuRcmServerTest (testNo);
        if (status < 0)
            Osal_printf ("Error in RCM Server sample\n");
    }

exit:
    Osal_printf ("\n== Sample End ==\n");

    /* Trace for TITAN support */
    if (status < 0)
        Osal_printf ("test_case_status=%d\n", status);
    else
        Osal_printf ("test_case_status=0\n");

    return status;
}
Example #20
0
/*
 *  ======== fxnDouble ========
 */
Int32 fxnDouble (UInt32 dataSize, UInt32 *data)
{
    RCM_Remote_FxnDoubleArgs * args;
    Int                        a;
    Int                        result;

    args = (RCM_Remote_FxnDoubleArgs *)data;
    a = args->a;
    result = a * 2;

    Osal_printf ("Executed Remote Function fxnDouble, result = %d\n", result);

    return result;
}
Example #21
0
static Void printUsage (Void)
{
    Osal_printf ("\nInvalid arguments!\n"
                 "Usage: ./syslink_daemon.out [-f] <[-s] <SysM3 image file>> "
                 "[<[-a] <AppM3 image file>>]\n"
                 "Rules: - Full paths must be provided for image files.\n"
                 "       - Use '-f' option to run as a regular process.\n"
                 "       - Images can be specified in any order as long as\n"
                 "         the corresponding option is specified.\n"
                 "       - All images not preceded by an option are applied\n"
                 "         to the cores whose images are not already\n"
                 "         specified in the order of SysM3, AppM3\n\n");
    exit (EXIT_FAILURE);
}
Example #22
0
/*!
 *  @brief      This is the worker thread which polls for events.
 *
 *  @param      attrs module attributes
 *
 *  @sa
 */
Void
_NotifyDrvUsr_eventWorker (Void * arg)
{
    Int32                 status = Notify_S_SUCCESS;
    UInt32                nRead  = 0;
    NotifyDrv_EventPacket packet;
    sigset_t              blockSet;

    GT_1trace (curTrace, GT_ENTER, "_NotifyDrvUsr_eventWorker", arg);

    if (sigfillset (&blockSet) != 0) {
        perror ("Event worker thread error in sigfillset");
        pthread_exit (NULL);
    }

    if (pthread_sigmask (SIG_BLOCK, &blockSet, NULL) != 0) {
        perror ("Event worker thread error in setting sigmask");
        pthread_exit (NULL);
    }

    while (status >= 0) {
        memset (&packet, 0, sizeof (NotifyDrv_EventPacket));
        packet.pid = getpid ();
        nRead = read (IpcDrv_handle,
                      &packet,
                      sizeof (NotifyDrv_EventPacket));
        if (nRead == sizeof (NotifyDrv_EventPacket)) {
            /* check for termination packet */
            if (packet.isExit  == TRUE) {
                pthread_exit (NULL);
            }

            if (packet.func != NULL) {
                packet.func (packet.procId,
                             packet.lineId,
                             packet.eventId,
                             packet.param,
                             packet.data);
            }
        }
        else if (nRead == -1) {
            Osal_printf("_NotifyDrvUsr_eventWorker: nRead returned -1\n");
            break;
        }
    }

    GT_0trace (curTrace, GT_LEAVE, "_NotifyDrvUsr_eventWorker");
}
Example #23
0
/*
 *  ======== MpuRcmClientTest ========
 */
Int MpuRcmClientTest(Int testCase)
{
    Int status = 0;

    Osal_printf ("MpuRcmClientTest: Testing RCM Client on MPU\n");

    status = ipcSetup (testCase);
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: ipcSetup failed, status [0x%x]\n");
        goto exit;
    }

    status = CreateRcmClient (testCase);
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: Error in creating RcmClient \n");
        goto exit;
    }

    status = GetSymbolIndex ();
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: Error in GetSymbolIndex \n");
        goto exit;
    }

    status = TestExec ();
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: Error in TestExec \n");
        goto exit;
    }

    /* status = TestExecDpc ();
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: Error in TestExecDpc \n");
        goto exit;
    }

    status = TestExecNoWait ();
    if (status < 0) {
        Osal_printf ("MpuRcmClientTest: Error in TestExecNoWait \n");
        goto exit;
    } */

    status = RcmClientCleanup (testCase);
    if (status < 0)
        Osal_printf ("MpuRcmClientTest: Error in RcmClientCleanup \n");

exit:
    Osal_printf ("MpuRcmClientTest: Leaving MpuRcmClientTest()\n");
    return status;
}
/*!
 *  @brief      Function to retrieve physical address of given a remote
 *              Processor's virtual address.
 *
 *              Return value of less than or equal to zero
 *              indicates the translation failure
 *
 *  @param      remoteAddr  The slave's address
 *  @param      physAddr    Translated physical address.
 *  @param      procId      Remote Processor Id.
  *
 *  @sa         SysLinkMemUtils_virtToPhysPages
 */
Int
SysLinkMemUtils_virtToPhys (UInt32          remoteAddr,
                            UInt32 *        physAddr,
                            ProcMgr_ProcId  procId)
{
    /* FIX ME: Hack for Tiler */
    if (remoteAddr >= TILER_ADDRESS_START && remoteAddr <= TILER_ADDRESS_END) {
        *physAddr = remoteAddr;
        printf("Translated Address = 0x%x\n", remoteAddr);
        return PROCMGR_SUCCESS;
    }
    else {
        Osal_printf("NON-TILER ADDRESS TRANSLATIONS NOT SUPPORTED"
                    "remoteAddr = 0x%x\n",remoteAddr );
        return PROCMGR_E_FAIL;
    }
}
Example #25
0
/*!
 * ======== VirtQueue_create ========
 */
VirtQueue_Handle VirtQueue_create (VirtQueue_callback callback, UInt16 procId,
                                   UInt16 id, UInt32 vaddr, UInt32 paddr,
                                   UInt32 num, UInt32 align, Void *arg)
{
    VirtQueue_Object *vq = NULL;

    vq = Memory_alloc(NULL, sizeof(VirtQueue_Object), 0, NULL);
    if (!vq) {
        return (NULL);
    }

    vq->callback = callback;
    vq->id = id;
    numQueues++;
    vq->procId = procId;
    vq->intId = coreIntId[procId];
    vq->last_avail_idx = 0;
    vq->arg = arg;

    /* init the vring */
    vring_init(&(vq->vring), num, (void *)vaddr, align);

    vq->num_free = num;
    vq->last_used_idx = 0;
    vq->vaddr = vaddr;
    vq->paddr = paddr;

    vq->vring.avail->idx = 0;
    vq->vring.used->idx = 0;

    /* Initialize the flags */
    vq->vring.avail->flags = 0;
    vq->vring.used->flags = 0;

    /* Store the VirtQueue locally */
    if (queueRegistry[procId][vq->id%2] == NULL)
        queueRegistry[procId][vq->id%2] = vq;
    else {
        Osal_printf ("VirtQueue ID %d already created", id);
        Memory_free(NULL, vq, sizeof(VirtQueue_Object));
        vq = NULL;
    }

    return (vq);
}
Void printUsage (Void)
{
    Osal_printf ("Usage: ./rcm_singletest.out <Test#> <Sub Test#>\n"
                    "Options:\n");
    Osal_printf ("\t./rcm_singletest.out 1 1 : "
                    "MPU RCM Client <--> SysM3 RCM Server\n");
    Osal_printf ("\t./rcm_singletest.out 1 2 : "
                    "MPU RCM Server <--> SysM3 RCM Client\n");
    Osal_printf ("\t./rcm_singletest.out 2 1 : "
                    "MPU RCM Client <--> AppM3 RCM Server\n");
    Osal_printf ("\t./rcm_singletest.out 2 2 : "
                    "MPU RCM Server <--> AppM3 RCM Client\n");
    Osal_printf ("\t./rcm_singletest.out 3 1 : "
                    "MPU RCM Client <--> Tesla RCM Server\n");
    Osal_printf ("\t./rcm_singletest.out 3 2 : "
                    "MPU RCM Server <--> Tesla RCM Client\n");

    return;
}
int main (int argc, char ** argv)
{
    Int status             = 0;
    Int i, j;

    /*
     *  Must be at least one set of procId and outfile. So argc cannot be odd
     */
    if ((argc < 3) || (argc / 2 * 2 == argc) || (argc > 7)) {
        Osal_printf ("uiaDaemon <procId> <outfile> [<procId> <outfile>] [<procId> <outfile>]\n");
        return (-1);
    }

    for (i = 0, j = 1 ; i < argc/2; i++, j = j + 2) {
        loader_procId[i] = strtol (argv [j], NULL, 16);
        loader_filePath[i] = argv [j + 1];
        loader_numProcessors++;
    }

    Osal_printf ("Running on %d processors\n", loader_numProcessors);

    Osal_printf ("Calling SysLink_setup\n");
    SysLink_setup ();

    Osal_printf ("Calling loader_startup\n");
    status = loader_startup ();

    Osal_printf ("Calling loader_execute\n");
    status = loader_execute ();

    Osal_printf ("Calling loader_shutdown\n");
    status = loader_shutdown ();

    Osal_printf ("Calling SysLink_destroy\n");
    SysLink_destroy ();

    return (0);
}
/*!
 *  @brief  Module initialization  function for Linux driver.
 */
static
int __init SyslinkMemMgrDrv_initializeModule (Void)
{
    int result = 0;

    /* Display the version info and created date/time */
    Osal_printf ("SyslinkMemMgr sample module created on Date:%s Time:%s\n",
                 __DATE__,
                 __TIME__);

    Osal_printf ("SyslinkMemMgrDrv_initializeModule\n");

    /* Enable/disable levels of tracing. */
    if (TRACE != NULL) {
        Osal_printf ("Trace enable %s\n", TRACE) ;
        SyslinkMemMgrDrv_enableTrace = simple_strtol (TRACE, NULL, 16);
        if (    (SyslinkMemMgrDrv_enableTrace != 0)
            &&  (SyslinkMemMgrDrv_enableTrace != 1)) {
            Osal_printf ("Error! Only 0/1 supported for TRACE\n") ;
        }
        else if (SyslinkMemMgrDrv_enableTrace == TRUE) {
            curTrace = GT_TraceState_Enable;
        }
        else if (SyslinkMemMgrDrv_enableTrace == FALSE) {
            curTrace = GT_TraceState_Disable;
        }
    }

    if (TRACEENTER != NULL) {
        Osal_printf ("Trace entry/leave prints enable %s\n", TRACEENTER) ;
        SyslinkMemMgrDrv_enableTraceEnter = simple_strtol (TRACEENTER, NULL, 16);
        if (    (SyslinkMemMgrDrv_enableTraceEnter != 0)
            &&  (SyslinkMemMgrDrv_enableTraceEnter != 1)) {
            Osal_printf ("Error! Only 0/1 supported for TRACEENTER\n") ;
        }
        else if (SyslinkMemMgrDrv_enableTraceEnter == TRUE) {
            curTrace |= GT_TraceEnter_Enable;
        }
    }

    if (TRACEFAILURE != NULL) {
        Osal_printf ("Trace SetFailureReason enable %s\n", TRACEFAILURE) ;
        SyslinkMemMgrDrv_enableTraceFailure = simple_strtol (TRACEFAILURE,
                                                          NULL,
                                                          16);
        if (    (SyslinkMemMgrDrv_enableTraceFailure != 0)
            &&  (SyslinkMemMgrDrv_enableTraceFailure != 1)) {
            Osal_printf ("Error! Only 0/1 supported for TRACEENTER\n") ;
        }
        else if (SyslinkMemMgrDrv_enableTraceFailure == TRUE) {
            curTrace |= GT_TraceSetFailure_Enable;
        }
    }

    if (TRACECLASS != NULL) {
        Osal_printf ("Trace class %s\n", TRACECLASS) ;
        SyslinkMemMgrDrv_traceClass = simple_strtol (TRACECLASS, NULL, 16);
        if (    (SyslinkMemMgrDrv_enableTraceFailure != 1)
            &&  (SyslinkMemMgrDrv_enableTraceFailure != 2)
            &&  (SyslinkMemMgrDrv_enableTraceFailure != 3)) {
            Osal_printf ("Error! Only 1/2/3 supported for TRACECLASS\n") ;
        }
        else {
            SyslinkMemMgrDrv_traceClass =
                         SyslinkMemMgrDrv_traceClass << (32 - GT_TRACECLASS_SHIFT);
            curTrace |= SyslinkMemMgrDrv_traceClass;
        }
    }

    Osal_printf ("curTrace value: 0x%x\n", curTrace);

    /* Initialize the OsalDriver */
    OsalDriver_setup ();

    SyslinkMemMgrDrv_osalDrvHandle = SyslinkMemMgrDrv_registerDriver ();
    if (SyslinkMemMgrDrv_osalDrvHandle == NULL) {
        /*! @retval MEMMGR_E_OSFAILURE Failed to register SyslinkMemMgr
                                        driver with OS! */
        result = -EFAULT;
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "SyslinkMemMgrDrv_initializeModule",
                             MEMMGR_E_OSFAILURE,
                             "Failed to register SyslinkMemMgr driver with OS!");
    }

    Osal_printf ("SyslinkMemMgrDrv_initializeModule 0x%x\n", result);

    return result;
}
Example #29
0
/*
 *  ======== CreateRcmClient ========
 */
Int CreateRcmClient(Int testCase)
{
    RcmClient_Params    rcmClientParams;
    Int                 count           = 0;
    Int                 status          = 0;

    /* Size (in bytes) of RCM header including the messageQ header */
    /* RcmClient_Message member data[1] is the start of the payload */
    Osal_printf ("CreateRcmClient: Size of RCM header in bytes = %d \n",
                            RcmClient_getHeaderSize());

    /* Rcm client module setup*/
    Osal_printf ("CreateRcmClient: RCM Client module setup.\n");
    RcmClient_init ();

    /* Rcm client module params init*/
    Osal_printf ("CreateRcmClient: RCM Client module params init.\n");
    status = RcmClient_Params_init (&rcmClientParams);
    if (status < 0) {
        Osal_printf ("CreateRcmClient: Error in RCM Client instance params "
                        "init \n");
        goto exit;
    }
    Osal_printf ("CreateRcmClient: RCM Client instance params init "
                    "passed \n");

    /* Create an rcm client instance */
    Osal_printf ("CreateRcmClient: Creating RcmClient instance \n");
    rcmClientParams.callbackNotification = 0; /* disable asynchronous exec */
    rcmClientParams.heapId = RCM_MSGQ_HEAPID;

    while ((rcmClientHandle == NULL) && (count++ < MAX_CREATE_ATTEMPTS)) {
        status = RcmClient_create (remoteServerName, &rcmClientParams,
                                    &rcmClientHandle);
        if (status < 0) {
            if (status == RcmClient_E_SERVERNOTFOUND) {
                Osal_printf ("CreateRcmClient: Unable to open remote"
                                "server %d time \n", count);
            }
            else {
                Osal_printf ("CreateRcmClient: Error in RCM Client "
                                "create \n");
                goto exit;
            }
        }
    }

    if (MAX_CREATE_ATTEMPTS <= count) {
        Osal_printf ("CreateRcmClient: Timeout... could not connect with"
                     "remote server\n");
    }
    else {
        Osal_printf ("CreateRcmClient: RCM Client create passed \n");
    }

exit:
    Osal_printf ("CreateRcmClient: Leaving CreateRcmClient() \n");
    return status;
}
Example #30
0
/*
 *  ======== RcmClientCleanup ========
 */
Int RcmClientCleanup (Int testCase)
{
    Int                  status             = 0;
    RcmClient_Message  * rcmMsg             = NULL;
    RcmClient_Message  * returnMsg          = NULL;
    UInt                 rcmMsgSize;
    RCM_Remote_FxnArgs * fxnExitArgs;
#if !defined(SYSLINK_USE_DAEMON)
    ProcMgr_StopParams   stopParams;
#endif

    Osal_printf ("\nRcmClientCleanup: Entering RcmClientCleanup()\n");

    /* Send terminate message */
    /* Allocate a remote command message */
    rcmMsgSize = sizeof(RCM_Remote_FxnArgs);
    status = RcmClient_alloc (rcmClientHandle, rcmMsgSize, &rcmMsg);
    if (status < 0) {
        Osal_printf ("RcmClientCleanup: Error allocating RCM message\n");
        goto exit;
    }

    /* Fill in the remote command message */
    rcmMsg->fxnIdx = fxnExitIdx;
    fxnExitArgs = (RCM_Remote_FxnArgs *)(&rcmMsg->data);
    fxnExitArgs->a = 0xFFFF;

#if !defined(SYSLINK_USE_DAEMON)
    /* Execute the remote command message */
    Osal_printf ("RcmClientCleanup: calling RcmClient_execDpc \n");
    status = RcmClient_execDpc (rcmClientHandle, rcmMsg, &returnMsg);
    if (status < 0) {
        Osal_printf ("RcmClientCleanup: RcmClient_execDpc error [0x%x]\n",
                        status);
        goto exit;
    }
#endif /* !defined(SYSLINK_USE_DAEMON) */

    /* Return message to the heap */
    Osal_printf ("RcmClientCleanup: Calling RcmClient_free \n");
    RcmClient_free (rcmClientHandle, returnMsg);

    /* Delete the rcm client */
    Osal_printf ("RcmClientCleanup: Delete RCM client instance \n");
    status = RcmClient_delete (&rcmClientHandle);
    if (status < 0)
        Osal_printf ("RcmClientCleanup: Error in RCM Client instance delete"
                     " [0x%x]\n", status);
    else
        Osal_printf ("RcmClientCleanup: RcmClient_delete status: [0x%x]\n",
                        status);

    /* Rcm client module destroy */
    Osal_printf ("RcmClientCleanup: Destroy RCM client module \n");
    RcmClient_exit ();

    /* Finalize modules */
#if !defined(SYSLINK_USE_DAEMON)    // Do not call ProcMgr_stop if using daemon
    status = MessageQ_unregisterHeap (RCM_MSGQ_HEAPID);
    if (status < 0)
        Osal_printf ("RcmClientCleanup: Error in MessageQ_unregisterHeap"
                     " [0x%x]\n", status);
    else
        Osal_printf ("RcmClientCleanup: MessageQ_unregisterHeap status:"
                     " [0x%x]\n", status);

    if (heapHandle) {
        status = HeapBufMP_delete (&heapHandle);
        if (status < 0)
            Osal_printf ("RcmClientCleanup: Error in HeapBufMP_delete [0x%x]\n",
                            status);
        else
            Osal_printf ("RcmClientCleanup: HeapBufMP_delete status: [0x%x]\n",
                            status);
    }

    if (heapBufPtr) {
        Memory_free (srHeap, heapBufPtr, heapSize);
    }

    stopParams.proc_id = remoteIdClient;
    if (testCase == 2) {
        status = ProcMgr_stop(procMgrHandleClient1, &stopParams);
        if (status < 0)
            Osal_printf ("RcmClientCleanup: Error in ProcMgr_stop [0x%x]\n",
                            status);
        else
            Osal_printf ("RcmClientCleanup: ProcMgr_stop status: [0x%x]\n",
                            status);
        stopParams.proc_id = MultiProc_getId (SYSM3_PROC_NAME);
    }

    status = ProcMgr_stop(procMgrHandleClient, &stopParams);
    if (status < 0)
        Osal_printf ("RcmClientCleanup: Error in ProcMgr_stop [0x%x]\n",
                        status);
    else
        Osal_printf ("RcmClientCleanup: ProcMgr_stop status: [0x%x]\n",
                        status);
#endif

    if (testCase == 2) {
        status =  ProcMgr_detach (procMgrHandleClient1);
        Osal_printf ("RcmClientCleanup: ProcMgr_detach status [0x%x]\n",
                        status);

        status = ProcMgr_close (&procMgrHandleClient1);
        if (status < 0)
            Osal_printf ("RcmClientCleanup: Error in ProcMgr_close [0x%x]\n",
                            status);
        else
            Osal_printf ("RcmClientCleanup: ProcMgr_close status: [0x%x]\n",
                            status);
    }

    status =  ProcMgr_detach (procMgrHandleClient);
    Osal_printf ("RcmClientCleanup: ProcMgr_detach status [0x%x]\n", status);

    status = ProcMgr_close (&procMgrHandleClient);
    if (status < 0)
        Osal_printf ("RcmClientCleanup: Error in ProcMgr_close [0x%x]\n",
                        status);
    else
        Osal_printf ("RcmClientCleanup: ProcMgr_close status: [0x%x]\n",
                        status);

    status = Ipc_destroy ();
    if (status < 0)
        Osal_printf("RcmClientCleanup: Error in Ipc_destroy [0x%x]\n", status);
    else
        Osal_printf("RcmClientCleanup: Ipc_destroy status: [0x%x]\n", status);

exit:
    Osal_printf ("RcmClientCleanup: Leaving RcmClientCleanup()\n");
    return status;
}