/*
* ======== main ========
*/
Int main(Int argc, Char* argv[])
{
UInt32 myArg1 = 12345;
UInt32 myArg2 = 67890;
UInt16 myProcId = MultiProc_self();
Int status;
/* Register the functions to be called */
System_printf("Registering myFxn1 & myArg1 to event #%d..\n", EVENT);
Notify_registerEvent(myProcId, 0, EVENT,
(Notify_FnNotifyCbck)myFxn1, (UArg)&myArg1);
System_printf("Registering myFxn2 & myArg2 to event #%d..\n", EVENT);
Notify_registerEvent(myProcId, 0, EVENT,
(Notify_FnNotifyCbck)myFxn2, (UArg)&myArg2);
/* Send an event */
System_printf("Sending event #%d (myFxn1 and myFxn2 should run)\n", EVENT);
Notify_sendEvent(myProcId, 0, EVENT, 0xaaaaa, TRUE);
/* Unregister one of the functions */
System_printf("Unregistering myFxn1 + myArg1\n");
status = Notify_unregisterEvent(myProcId, 0, EVENT,
(Notify_FnNotifyCbck)myFxn1,
(UArg)&myArg1);
if (status < 0) {
System_abort("Listener not found! (THIS IS UNEXPECTED)\n");
}
/* Send an event */
System_printf("Sending event #%d (myFxn2 should run)\n", EVENT);
Notify_sendEvent(myProcId, 0, EVENT, 0xbbbbb, TRUE);
/* Disable event */
System_printf("Disabling event #%d:\n", EVENT);
Notify_disableEvent(myProcId, 0, EVENT);
/* Send an event (nothing should happen) */
System_printf("Sending event #%d (nothing should happen)\n", EVENT);
Notify_sendEvent(myProcId, 0, EVENT, 0xbbbbb, TRUE);
/* Enable event */
System_printf("Enabling event #%d:\n", EVENT);
Notify_enableEvent(myProcId, 0, EVENT);
/* Send an event */
System_printf("Sending event #%d (myFxn2 should run)\n", EVENT);
Notify_sendEvent(myProcId, 0, EVENT, 0xbbbbb, TRUE);
System_printf("Test completed\n");
return (0);
}
/*
* ======== taskLoad ========
*/
Void task(UArg arg1, UArg arg2)
{
UInt count = 1;
Int status = Ipc_S_SUCCESS;
UInt16 remoteProcId = MultiProc_getId("HOST");
do {
status = Ipc_attach(remoteProcId);
} while (status < 0);
Notify_registerEvent(remoteProcId, 0, SHUTDOWN,
(Notify_FnNotifyCbck)notifyCallbackFxn, 0);
while (shutdownFlag == FALSE) {
Semaphore_pend(sem, BIOS_WAIT_FOREVER);
/* Benchmark how long it takes to flip all the bits */
Log_write1(UIABenchmark_start, (xdc_IArg)"Reverse");
reverseBits(buffer, sizeof(buffer));
Log_write1(UIABenchmark_stop, (xdc_IArg)"Reverse");
Log_print1(Diags_USER1, "count = %d", count++);
}
/* Start shutdown process */
Notify_unregisterEvent(remoteProcId, 0, SHUTDOWN,
(Notify_FnNotifyCbck)notifyCallbackFxn, 0);
do {
status = Ipc_detach(remoteProcId);
} while (status < 0);
Ipc_stop();
}
Int SystemCfg_attachHook(UArg userCtx, UInt16 remoteProcId)
{
Int status;
List_Elem * elem = NULL;
SystemCfg_Object * obj = NULL;
IArg key;
/* find object on module list */
key = GateH_enter(Mod_gate);
while ((elem = List_next(Mod_objList, elem)) != NULL) {
obj = (SystemCfg_Object *)elem;
if (obj->remoteProcId == remoteProcId) {
break;
}
obj = NULL;
}
GateH_leave(Mod_gate, key);
if (obj != NULL) {
status = Notify_registerEvent(remoteProcId, SystemCfg_NotifyLineId,
SystemCfg_HostDspEvtNum, SystemCfg_notifyCB, (UArg)obj);
if (status < 0) {
Log_error1(FXNN": Notify_registerEvent() error %d", (IArg)status);
}
}
return(status);
}
/*
* ======== main ========
* Synchronizes all processors (in Ipc_start), calls BIOS_start, and registers
* for an incoming event
*/
Int main(Int argc, Char* argv[])
{
Int status;
UInt numProcs = MultiProc_getNumProcessors();
/*
* Determine which processors Notify will communicate with based on the
* local MultiProc id. Also, create a processor-specific Task.
*/
srcProc = ((MultiProc_self() - 1 + numProcs) % numProcs);
dstProc = ((MultiProc_self() + 1) % numProcs);
System_printf("main: MultiProc id = %d\n", MultiProc_self());
System_printf("main: MultiProc name = %s\n",
MultiProc_getName(MultiProc_self()));
/*
* Register call back with Notify. It will be called when the processor
* with id = srcProc sends event number EVENTID to this processor.
*/
status = Notify_registerEvent(srcProc, INTERRUPT_LINE, EVENTID,
(Notify_FnNotifyCbck)cbFxn, NULL);
if (status < 0) {
System_abort("Notify_registerEvent failed\n");
}
BIOS_start();
return (0);
}
/*
* ======== SemaphoreMP_registerEvent ========
*/
Int SemaphoreMP_registerEvent(UArg arg, UInt16 remoteProcId)
{
Int status;
status = Notify_registerEvent(remoteProcId, 0, SemaphoreMP_notifyEventId,
SemaphoreMP_cbFxn, NULL);
Assert_isTrue(status >= 0, ti_sdo_ipc_Ipc_A_internal);
return (0);
}
/*
* ======== main ========
*/
Int main(Int argc, Char* argv[])
{
Int status;
armProcId = MultiProc_getId("HOST");
System_printf("main: MultiProc id = %d\n", MultiProc_self());
/*
* Ipc_start() calls Ipc_attach() to synchronize all remote processors
* because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
*/
status = Ipc_start();
if (status < 0) {
System_abort("Ipc_start failed\n");
}
/*
* Register cbFxn with Notify. It will be called when Arm
* sends event number EVENTID to instance.
* Passing in 0xFEED as the arg just for validation.
*/
status = Notify_registerEvent(armProcId, LINE_0, EVENTID,
(Notify_FnNotifyCbck)cbFxnLine0, 0xFEED);
if (status < 0) {
System_abort("Notify_registerEvent failed\n");
}
status = Notify_registerEvent(armProcId, LINE_1, EVENTID,
(Notify_FnNotifyCbck)cbFxnLine1, 0xBEEF);
if (status < 0) {
System_abort("Notify_registerEvent failed\n");
}
BIOS_start();
return (0);
}
Int32 System_ipcNotifyInit()
{
UInt32 procId, i;
Int32 status;
memset(gSystem_ipcObj.notifyCb, 0, sizeof(gSystem_ipcObj.notifyCb));
i = 0;
while (gSystem_ipcEnableProcId[i] != SYSTEM_PROC_MAX)
{
procId = gSystem_ipcEnableProcId[i];
if ((procId != System_getSelfProcId()) && (procId != SYSTEM_PROC_INVALID))
{
Vps_printf
(" %d: SYSTEM: Notify register to [%s] line %d, event %d ... \n",
Utils_getCurTimeInMsec(), MultiProc_getName(procId),
SYSTEM_IPC_NOTIFY_LINE_ID, SYSTEM_IPC_NOTIFY_EVENT_ID);
if (Notify_intLineRegistered(procId, SYSTEM_IPC_NOTIFY_LINE_ID) ==
FALSE)
{
UTILS_assert(0);
}
if (Notify_eventAvailable
(procId, SYSTEM_IPC_NOTIFY_LINE_ID,
SYSTEM_IPC_NOTIFY_EVENT_ID) == FALSE)
{
UTILS_assert(0);
}
status = Notify_registerEvent(procId,
SYSTEM_IPC_NOTIFY_LINE_ID,
SYSTEM_IPC_NOTIFY_EVENT_ID,
System_ipcNotifyHandler, NULL);
UTILS_assert(status == Notify_S_SUCCESS);
}
i++;
}
return status;
}
Int SystemCfg_createLocalResources(Void)
{
Error_Block eb;
SemThread_Params semThreadP;
HeapBufMP_Params heapBufMPP;
Int count;
Char heapName[32];
Int status = 0;
struct SystemCfg *stateObj = &SystemCfg_State;
static Int heapId = 1;
Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN);
Error_init(&eb);
/* create sync object used to wait on remote core startup */
SemThread_Params_init(&semThreadP);
semThreadP.mode = SemThread_Mode_COUNTING;
SemThread_construct(&stateObj->semObj, 0, &semThreadP, &eb);
if (Error_check(&eb)) {
/* Log_error() */
Log_print3(Diags_USER8,
"Error: %s, line %d: %s: SemThread_construct() failed",
(IArg)__FILE__, (IArg)__LINE__, (IArg)FXNN);
status = -1;
goto leave;
}
stateObj->semH = SemThread_handle(&stateObj->semObj);
/* register notify callback for ready event from remote core */
status = Notify_registerEvent(stateObj->hostProcId, Global_NotifyLineId,
Global_HostDspEvtNum, SystemCfg_notifyCB__P, (UArg)stateObj);
if (status < 0) {
/* Log_error() */
Log_print4(Diags_USER8,
"Error: %s, line %d: %s: "
"Notify_registerEventSingle() returned error %d",
(IArg)__FILE__, (IArg)__LINE__, (IArg)FXNN, (IArg)status);
goto leave;
}
/* create a heap for tiler usage */
Log_print0(Diags_USER2, FXNN": HeapBufMP_create for tiler");
HeapBufMP_Params_init(&heapBufMPP);
heapBufMPP.regionId = 0;
heapBufMPP.blockSize = 0x200; /* 512 B */
heapBufMPP.numBlocks = 8;
/* hack: make a unique heap name */
System_sprintf(heapName, "rcmHeap-%d", heapId);
heapBufMPP.name = heapName;
stateObj->heapH = HeapBufMP_create(&heapBufMPP);
if (stateObj->heapH == NULL) {
/* Log_error() */
Log_print3(Diags_USER8,
"Error: %s, line %d: %s: HeapBuf_create() failed",
(IArg)FXNN, (IArg)__FILE__, (IArg)__LINE__);
status = -1;
goto leave;
}
/* register this heap with MessageQ */
Log_print2(Diags_USER2,
FXNN": MessageQ_registerHeap: (heapH: 0x%x, heapId: %d)",
(IArg)(stateObj->heapH), (IArg)Global_TilerHeapId);
MessageQ_registerHeap((Ptr)(stateObj->heapH), Global_TilerHeapId);
/* Send create done event to remote core. Need to loop in case
* the remote core has not yet registered with notify to receive
* this event.
*/
Log_print0(Diags_USER1, FXNN": send EvtCreateDone to remote core");
count = 0;
do {
status = Notify_sendEvent(stateObj->hostProcId, Global_NotifyLineId,
Global_HostDspEvtNum, Global_EvtCreateDone, TRUE);
if (status == Notify_E_EVTNOTREGISTERED) {
Thread_sleep(500, &eb); /* 0.5 ms */
}
} while ((++count < 10) && (status == Notify_E_EVTNOTREGISTERED));
if (status < 0) {
/* Log_error() */
Log_print5(Diags_USER8,
"Error: %s, line %d: %s: Notify_sendEvent() returned error %d,"
"giving up after %d tries", (IArg)__FILE__, (IArg)__LINE__,
(IArg)FXNN, (IArg)status, (IArg)count);
goto leave;
}
/* wait for create done event from remote core */
Log_print0(Diags_USER1, FXNN": waiting for EvtCreateDone event...");
SemThread_pend(stateObj->semH, SemThread_FOREVER, &eb);
if (Error_check(&eb)) {
/* Log_error() */
Log_print3(Diags_USER8,
"Error: %s, line %d: %s: SemThread_pend() returned with error",
(IArg)__FILE__, (IArg)__LINE__, (IArg)FXNN);
status = -1;
goto leave;
}
Log_print0(Diags_USER1, FXNN": ...received EvtCreatDone event");
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
