/*!
* ======== VirtQueue_startup ========
*/
Void VirtQueue_startup()
{
hostProcId = MultiProc_getId("HOST");
dspProcId = MultiProc_getId("DSP");
sysm3ProcId = MultiProc_getId("CORE0");
appm3ProcId = MultiProc_getId("CORE1");
/* Initilize the IpcPower module */
IpcPower_init();
/*
* DSP can be used to prototype communications with CORE0 instead of
* HOST
*/
if (MultiProc_self() == dspProcId) {
memset((void *)RP_MSG_A9_SYSM3_VRING_DA, 0,
RP_MSG_RING_SIZE * 2 + RP_MSG_BUFS_SPACE);
InterruptM3_intRegister(VirtQueue_isr);
InterruptM3_intSend(sysm3ProcId, (UInt)RP_MSG_MBOX_READY);
InterruptM3_intSend(sysm3ProcId, (0xA0000000));
InterruptM3_intSend(appm3ProcId, (UInt)RP_MSG_MBOX_READY);
InterruptM3_intSend(appm3ProcId, (0xA0000000));
buf_addr = (Ptr)RP_MSG_A9_SYSM3_VRING_DA;
}
else if (MultiProc_self() == sysm3ProcId)
InterruptM3_intRegister(VirtQueue_isr);
else if (MultiProc_self() == appm3ProcId)
InterruptM3_intRegister(VirtQueue_isr);
}
/*!
* ======== VirtQueue_startup ========
*/
Void VirtQueue_startup()
{
hostProcId = MultiProc_getId("HOST");
#ifndef SMP
dsp1ProcId = MultiProc_getId("DSP1");
sysm3ProcId = MultiProc_getId("CORE0");
appm3ProcId = MultiProc_getId("CORE1");
#endif
#ifdef DSP
intInfo.intVectorId = DSPEVENTID;
#else
/* Initilize the IpcPower module */
IpcPower_init();
#endif
/*
* Wait for HLOS (Virtio device) to indicate that priming of host's receive
* buffers is complete, indicating that host is ready to send.
*
* Though this is a Linux Virtio configuration status, it must be
* implemented by each non-Linux HLOS as well.
*/
Log_print1(Diags_USER1, "VirtQueue_startup: VDEV status: 0x%x\n",
Resource_getVdevStatus(VIRTIO_ID_RPMSG));
Log_print0(Diags_USER1, "VirtQueue_startup: Polling VDEV status...\n");
while (Resource_getVdevStatus(VIRTIO_ID_RPMSG) != VRING_BUFS_PRIMED);
Log_print1(Diags_USER1, "VirtQueue_startup: VDEV status: 0x%x\n",
Resource_getVdevStatus(VIRTIO_ID_RPMSG));
InterruptProxy_intRegister(hostProcId, &intInfo, (Fxn)VirtQueue_isr, NULL);
Log_print0(Diags_USER1, "Passed VirtQueue_startup\n");
}
/*
* ======== tsk1_func ========
* Receive and return messages until the die request comes.
*/
Void tsk1_func(UArg arg0, UArg arg1) {
UInt16 hostProcId = MultiProc_getId("MPU");
while (Ipc_attach(hostProcId) < 0);
UInt16 appProcId = MultiProc_getId("AppM3");
while (Ipc_attach(appProcId) < 0);
comInitCoPro();
computationThread();
comClear();
Ipc_detach(appProcId);
Ipc_detach(hostProcId);
}
Int IpcResource_release(IpcResource_Handle handle,
IpcResource_ResHandle resHandle)
{
Int status;
Char msg[sizeof(IpcResource_Req) + sizeof(IpcResource_FreeData)];
IpcResource_Req *req = (Void *)msg;
IpcResource_FreeData *rel = (Void *)req->data;
if (!handle) {
System_printf("IpcResource_release: handle is NULL\n");
return IpcResource_E_INVALARGS;
}
req->reqType = IpcResource_ReqType_FREE;
rel->resHandle = resHandle;
status = MessageQCopy_send(MultiProc_getId("HOST"), handle->remote,
handle->endPoint, req, sizeof(msg));
if (status) {
System_printf("IpcResource_release: MessageQCopy_send "
"failed status %d\n", status);
}
return status;
}
/*
* ======== Server_init ========
*/
Void Server_init(Void)
{
Registry_Result result;
if (curInit++ != 0) {
return; /* already initialized */
}
/* register with xdc.runtime to get a diags mask */
result = Registry_addModule(&Registry_CURDESC, MODULE_NAME);
Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);
/* initialize module state */
Module.hostProcId = MultiProc_getId("HOST");
Module.lineId = SystemCfg_LineId;
Module.eventId = SystemCfg_AppEventId;
Module.semH = NULL;
Module.heapH = NULL;
Module.head = 0;
Module.tail = 0;
Module.error = 0;
Module.rcmServerH = NULL;
RcmServer_init();
}
/*!
* ======== Interrupt_intSend ========
* Send interrupt to the remote processor, identifying this core as source.
* If CORE0 BIT POS, we add DNUM to identify this core as the source;
* Otherwise, we just use the localIntId as the source bit position.
*/
Void Interrupt_intSend(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
UArg arg)
{
UInt32 val;
volatile UInt32 *ipcgr = (volatile UInt32 *)Interrupt_IPCGR0;
volatile UInt32 *ipcgrh = (volatile UInt32 *)Interrupt_IPCGRH;
UInt pos;
Assert_isTrue((intInfo != NULL), NULL);
pos = MAP_TO_BITPOS(intInfo->localIntId);
/*
* bit 0 is set to generate the interrupt.
* bits 4-7 are set to specify the interrupt generation source.
* The convention is that bit 4 (SRCS0) is used for core 0,
* bit 5 (SRCS1) for core 1, etc... .
*/
val = (1 << pos) | 1;
Log_print3(Diags_USER1,
"Interrupt_intSend: setting bit %d in SRCS as 0x%x to for rprocId #%d",
(IArg)pos, (IArg)val, (IArg)remoteProcId);
if (remoteProcId == MultiProc_getId("HOST"))
{
/* Interrupt is to be generated on the Host processor. Go through
* IPCGRH register
*/
*ipcgrh = val;
}
else
{
/* Interrupt is to be generated on another DSP. */
ipcgr[MAP_RPROCID_TO_COREID(remoteProcId)] = val;
}
}
/*
* ======== 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 IpcResource_disconnect(IpcResource_Handle handle)
{
Int status;
IpcResource_Req req;
if (!handle) {
System_printf("IpcResource_disconnect: handle is NULL\n");
}
req.resType = 0;
req.reqType = IpcResource_REQ_TYPE_DISCONN;
status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server,
handle->endPoint, &req, sizeof(req));
if (status) {
System_printf("IpcResource_disconnect: MessageQCopy_send "
"failed status %d\n", status);
return status;
}
status = MessageQCopy_delete(&handle->msgq);
if (status) {
System_printf("IpcResource_disconnect: MessageQCopy_delete "
"failed status %d\n", status);
return status;
}
Memory_free(NULL, handle, sizeof(*handle));
return 0;
}
Void Audio_systemProcInit (Void)
{
Int32 status;
Int16 procId;
Int16 state;
/*
* SysLink_setup is the first APIs needs to be called by user side
* application to use any SysLink functionality
*/
SysLink_setup ();
procId = MultiProc_getId ("DSP");
status = ProcMgr_open (&procMgrHandle, procId);
if (0 > status) {
AUDIO_ERROR_PRINT(("AUDIO: ProcMgr_open() Failed \n"));
goto EXIT;
}
state = ProcMgr_getState (procMgrHandle);
EXIT:
return;
}
Void copyTaskFxn(UArg arg0, UArg arg1)
{
MessageQCopy_Handle handle;
Char buffer[128];
UInt32 myEndpoint = 0;
UInt32 remoteEndpoint;
UInt16 dstProc;
UInt16 len;
Int i;
System_printf("copyTask %d: Entered...:\n", arg0);
dstProc = MultiProc_getId("HOST");
/* Create the messageQ for receiving (and get our endpoint for sending). */
handle = MessageQCopy_create(arg0, &myEndpoint);
NameMap_register("rpmsg-client-sample", arg0);
for (i = 0; i < APP_NUM_ITERATIONS; i++) {
/* Await a character message: */
MessageQCopy_recv(handle, (Ptr)buffer, &len, &remoteEndpoint,
MessageQCopy_FOREVER);
buffer[len] = '\0';
System_printf("copyTask %d: Received data: %s, len:%d\n", i + 1,
buffer, len);
/* Send data back to remote endpoint: */
MessageQCopy_send(dstProc, remoteEndpoint, myEndpoint, (Ptr)buffer, len);
}
/* Teardown our side: */
MessageQCopy_delete(&handle);
}
/*!
* ======== InterruptHost_intRegister ========
*/
Void InterruptHost_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
Fxn func, UArg arg)
{
UInt key;
Hwi_Params hwiAttrs;
/* Make sure that we're trying to talk to the HOST */
Assert_isTrue(remoteProcId == MultiProc_getId("DSP"),
ti_sdo_ipc_Ipc_A_invArgument);
/* Disable global interrupts */
key = Hwi_disable();
InterruptHost_intClear(remoteProcId, intInfo);
/* Register interrupt for communication between ARM and DSP */
Hwi_Params_init(&hwiAttrs);
hwiAttrs.maskSetting = Hwi_MaskingOption_SELF;
hwiAttrs.arg = arg;
Hwi_create(HOSTINT,
(Hwi_FuncPtr)func,
&hwiAttrs,
NULL);
/* Enable the mailbox interrupt to the DSP */
REG32(MAILBOX_IRQENABLE_GPP) = 0x4; /* Mailbox 0 */
/* Restore global interrupts */
Hwi_restore(key);
/* Unmask IVA_2_IRQ[10] to allow interrupt to come into DSP */
Hwi_enableInterrupt(HOSTINT);
}
/*
* ======== IpcMgr_ipcStartup ========
* Initialize MessageQ Transport stack built over RPMSG.
* This ends up calling RPMessage_init().
*
* Use for stacks built on MessageQ/TransportRpmsg only.
*/
Void IpcMgr_ipcStartup(Void)
{
UInt procId = MultiProc_getId("HOST");
Int status;
/* TransportRpmsgSetup will busy wait until host kicks ready to recv: */
status = TransportRpmsgSetup_attach(procId, 0);
Assert_isTrue(status >= 0, NULL);
/* Sets up to communicate with host's NameServer: */
status = NameServerRemoteRpmsg_attach(procId, 0);
Assert_isTrue(status >= 0, NULL);
#ifdef IpcMgr_USEDEH
/*
* When using DEH, initialize the Watchdog timers if not already done
* (i.e. late-attach)
*/
#ifdef IpcMgr_DSP
Watchdog_init((Void (*)(Void))ti_sysbios_family_c64p_Exception_handler);
#elif IpcMgr_IPU
Watchdog_init(ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I);
#endif
#endif
}
/*!
* ======== OffloadM3_init ========
*
* Initialize the OffloadM3 module, currently supported only on SysM3
*/
Void OffloadM3_init()
{
Task_Params taskParams;
Semaphore_Params mutexParams;
sysm3ProcId = MultiProc_getId("CORE0");
if (MultiProc_self() != sysm3ProcId)
return;
Semaphore_Params_init(&mutexParams);
mutexParams.mode = Semaphore_Mode_BINARY;
module.mutex = Semaphore_create(1, NULL, NULL);
module.created = FALSE;
module.semaphores[OFFLOAD_CREATE_IDX] = Semaphore_create(0, NULL, NULL);
module.semaphores[OFFLOAD_DELETE_IDX] = Semaphore_create(0, NULL, NULL);
Task_Params_init(&taskParams);
taskParams.instance->name = "OffloadM3_createTask";
taskParams.priority = xdc_runtime_knl_Thread_Priority_NORMAL;
taskParams.arg0 = (UArg)module.semaphores[OFFLOAD_CREATE_IDX];
module.tasks[OFFLOAD_CREATE_IDX] = Task_create(OffloadM3_createTask, &taskParams, NULL);
Task_Params_init(&taskParams);
taskParams.instance->name = "OffloadM3_deleteTask";
taskParams.priority = xdc_runtime_knl_Thread_Priority_HIGHEST;
taskParams.arg0 = (UArg)module.semaphores[OFFLOAD_DELETE_IDX];
module.tasks[OFFLOAD_DELETE_IDX] = Task_create(OffloadM3_deleteTask, &taskParams, NULL);
}
/*!
* ======== NotifySetup_attach ========
*/
Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
{
NotifyDriverShm_Params notifyShmParams;
NotifyDriverShm_Handle shmDrvHandle;
ti_sdo_ipc_Notify_Handle notifyHandle;
Error_Block eb;
Assert_isTrue(remoteProcId != MultiProc_getId("HOST"), NULL);
/* Initialize the error block */
Error_init(&eb);
/* init params and set default values */
NotifyDriverShm_Params_init(¬ifyShmParams);
notifyShmParams.intVectorId = NotifySetup_dspIntVectId;
notifyShmParams.localIntId = NotifySetup_SRCS_BITPOS_CORE0;
notifyShmParams.sharedAddr = sharedAddr;
notifyShmParams.remoteProcId = remoteProcId;
shmDrvHandle = NotifyDriverShm_create(¬ifyShmParams, &eb);
if (shmDrvHandle == NULL) {
return (Notify_E_FAIL);
}
notifyHandle = ti_sdo_ipc_Notify_create(
NotifyDriverShm_Handle_upCast(shmDrvHandle), remoteProcId, 0, NULL,
&eb);
if (notifyHandle == NULL) {
NotifyDriverShm_delete(&shmDrvHandle);
return (Notify_E_FAIL);
}
return (Notify_S_SUCCESS);
}
/*
* ======== IpcMgr_rpmsgStartup ========
* Initialize the RPMSG module. This calls VirtQueue_startup().
*
* Use for stacks built on RPMessage only.
*/
Void IpcMgr_rpmsgStartup(Void)
{
Assert_isTrue(MultiProc_self() != MultiProc_getId("HOST"), NULL);
RPMessage_init(MultiProc_getId("HOST"));
#ifdef IpcMgr_USEDEH
/*
* When using DEH, initialize the Watchdog timers if not already done
* (i.e. late-attach)
*/
#ifdef IpcMgr_DSP
Watchdog_init((Void (*)(Void))ti_sysbios_family_c64p_Exception_handler);
#elif IpcMgr_IPU
Watchdog_init(ti_sysbios_family_arm_m3_Hwi_excHandlerAsm__I);
#endif
#endif
}
Int IpcResource_setConstraints(IpcResource_Handle handle,
IpcResource_ResHandle resHandle,
UInt32 action,
Void *constraints)
{
Char msg[MAXMSGSIZE];
IpcResource_Ack *ack = (Void *)msg;
IpcResource_Req *req = (Void *)msg;
UInt16 rlen = sizeof(IpcResource_ConstraintData);
UInt16 alen = sizeof(*ack);
UInt16 len;
UInt32 remote;
Int status;
if (!handle) {
System_printf("IpcResource_setConstraints: Invalid paramaters\n");
return IpcResource_E_INVALARGS;
}
if (rlen && !constraints) {
System_printf("IpcResource_setConstraints: needs parameters\n");
return IpcResource_E_INVALARGS;
}
req->resType = 0;
req->reqType = action;
req->resHandle = resHandle;
memcpy(req->resParams, constraints, rlen);
status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server,
handle->endPoint, req, sizeof(*req) + rlen);
if (status) {
System_printf("IpcResource_setConstraints: MessageQCopy_send "
"failed status %d\n", status);
status = IpcResource_E_FAIL;
goto end;
}
if (action == IpcResource_REQ_TYPE_REL_CONSTRAINTS)
goto end;
status = MessageQCopy_recv(handle->msgq, ack, &len, &remote,
handle->timeout);
if (status) {
System_printf("IpcResource_setConstraints: MessageQCopy_recv "
"failed status %d\n", status);
status = (status == MessageQCopy_E_TIMEOUT) ? IpcResource_E_TIMEOUT :
IpcResource_E_FAIL;
goto end;
}
Assert_isTrue(len == (rlen + alen), NULL);
status = _IpcResource_translateError(ack->status);
end:
return status;
}
/*!
* ======== NotifySetup_numIntLines ========
* If remoteProc is HOST, say "0" so that Ipc_start skips the attach.
*/
UInt16 NotifySetup_numIntLines(UInt16 remoteProcId)
{
UInt16 retval = 1;
if (remoteProcId == MultiProc_getId("HOST")) {
retval = 0;
}
return (retval);
}
/*!
* ======== VirtQueue_startup ========
*/
Void VirtQueue_startup()
{
hostProcId = MultiProc_getId("HOST");
#ifndef SMP
dspProcId = MultiProc_getId("DSP");
sysm3ProcId = MultiProc_getId("CORE0");
appm3ProcId = MultiProc_getId("CORE1");
#endif
/* Initilize the IpcPower module */
IpcPower_init();
#if defined(M3_ONLY) && !defined(SMP)
if (MultiProc_self() == sysm3ProcId) {
OffloadM3_init();
}
#endif
InterruptProxy_intRegister(VirtQueue_isr);
}
Int dvsdk_grapx_display_rpc_display_toggle (Int instID)
{
Int status;
Assert_isTrue((MultiProc_self() != MultiProc_getId("VPSS-M3")), Assert_E_assertFailed);
status = dvsdk_grapx_display_rpc_remote_mode_init();
if (status >= 0) {
status = dvsdk_grapx_display_exec_rpc(instID, g_RemoteStubContext.nDisplayToggelFxnIdx);
}
return status;
}
/*
* ======== Processor_getCoreId ========
*/
UInt32 Processor_getCoreId(String name)
{
UInt16 coreId = MultiProc_getId(name);
if (coreId == MultiProc_INVALIDID) {
return (Processor_INVALIDID);
}
else {
return ((UInt32)coreId);
}
}
IpcResource_Handle IpcResource_connect(UInt timeout)
{
UInt16 dstProc;
UInt16 len;
UInt32 remote;
IpcResource_Handle handle;
IpcResource_Req req;
IpcResource_Ack ack;
Int status;
handle = Memory_alloc(NULL, sizeof(*handle), 0, NULL);
if (!handle) {
System_printf("IpcResource_connect: No memory");
return NULL;
}
handle->timeout = (!timeout) ? DEFAULT_TIMEOUT :
(timeout == IpcResource_FOREVER) ? MessageQCopy_FOREVER :
timeout;
dstProc = MultiProc_getId("HOST");
handle->msgq= MessageQCopy_create(MessageQCopy_ASSIGN_ANY,
&handle->endPoint);
req.resType = 0;
req.reqType = IpcResource_REQ_TYPE_CONN;
req.resHandle = 0;
status = MessageQCopy_send(dstProc, IpcResource_server,
handle->endPoint, &req, sizeof(req));
if (status) {
System_printf("IpcResource_connect: MessageQCopy_send "
" failed status %d\n", status);
goto err;
}
status = MessageQCopy_recv(handle->msgq, &ack, &len, &remote,
handle->timeout);
if (status) {
System_printf("IpcResource_connect: MessageQCopy_recv "
"failed status %d\n", status);
goto err;
}
status = _IpcResource_translateError(ack.status);
if (status) {
System_printf("IpcResource_connect: A9 Resource Manager "
"failed status %d\n", status);
goto err;
}
return handle;
err:
Memory_free(NULL, handle, sizeof(*handle));
return NULL;
}
/*
* ======== IPC_threadGeneratedInit ========
*/
Void IPC_threadGeneratedInit()
{
Int status;
UInt16 masterId;
masterId = MultiProc_getId("HOST");
do {
status = Ipc_attach(masterId);
} while (status < 0);
}
void platform_init()
{
Int status = 0;
UInt16 hostId = 0, sysProcId = 0;
/* clear HSDIVDER_CLKOUT2_DIV */
set_ivahd_opp(0);
/* Set up interprocessor notifications */
DEBUG("Setting up IPC");
status = Ipc_start();
if (status < 0) {
ERROR("Ipc_start failed: %08x", status);
return;
}
/* attach to host */
hostId = MultiProc_getId("MPU");
DEBUG("APPM3: IPC attaching to MPU, hostId = %d", hostId);
do {
status = Ipc_attach(hostId);
DEBUG("APPM3: IPC attaching... %08x", status);
} while (status < 0);
/* attach to other M3.. do we need this? */
sysProcId = MultiProc_getId("SysM3");
DEBUG("APPM3: IPC attaching to SysM3, sysProcId = %d", sysProcId);
do {
status = Ipc_attach(sysProcId);
DEBUG("APPM3: IPC attaching... %08x", status);
} while (status < 0);
/* maybe above stuff should move into dce_init().. */
dce_init();
DEBUG("APPM3: Completed IPC setup and Server Bringup");
return;
}
/*!
* ======== InterruptM3_intRegister ========
*/
Void InterruptM3_intRegister(Hwi_FuncPtr fxn)
{
Hwi_Params hwiAttrs;
UInt key;
hostProcId = MultiProc_getId("HOST");
dspProcId = MultiProc_getId("DSP");
sysm3ProcId = MultiProc_getId("CORE0");
appm3ProcId = MultiProc_getId("CORE1");
/* Disable global interrupts */
key = Hwi_disable();
userFxn = fxn;
Hwi_Params_init(&hwiAttrs);
hwiAttrs.maskSetting = Hwi_MaskingOption_LOWER;
if (Core_getId() == 0) {
Hwi_create(M3INT_MBX,
(Hwi_FuncPtr)InterruptM3_isr,
&hwiAttrs,
NULL);
/* InterruptM3_intEnable won't enable the Hwi */
Hwi_enableInterrupt(M3INT_MBX);
}
else {
Hwi_create(M3INT,
(Hwi_FuncPtr)InterruptM3_isr,
&hwiAttrs,
NULL);
}
/* Enable the mailbox interrupt to the M3 core */
InterruptM3_intEnable();
/* Restore global interrupts */
Hwi_restore(key);
}
/*
* ======== Server_init ========
*/
Void Server_init(Void)
{
Registry_Result result;
/* register with xdc.runtime to get a diags mask */
result = Registry_addModule(&Registry_CURDESC, MODULE_NAME);
Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);
/* initialize module object state */
Module.hostProcId = MultiProc_getId("HOST");
Module.slaveQue = NULL;
Module.hostGateMPHandle = NULL;
Module.slaveGateMPHandle = NULL;
}
/*
* ======== Processor_getCoreId ========
*/
UInt32 Processor_getCoreId(String name)
{
#if MESSAGEQ_ENABLED
UInt16 coreId = MultiProc_getId(name);
if (coreId == MultiProc_INVALIDID) {
return (Processor_INVALIDID);
}
else {
return (coreId);
}
#else
return (0);
#endif
}
/*!
* ======== NotifySetup_sharedMemReq ========
*/
SizeT NotifySetup_sharedMemReq(UInt16 remoteProcId, Ptr sharedAddr)
{
SizeT memReq;
NotifyDriverShm_Params params;
Assert_isTrue(remoteProcId != MultiProc_getId("HOST"), NULL);
NotifyDriverShm_Params_init(¶ms);
params.sharedAddr = sharedAddr;
params.intVectorId = NotifySetup_dspIntVectId;
params.remoteProcId = remoteProcId;
memReq = NotifyDriverShm_sharedMemReq(¶ms);
return(memReq);
}
/*
* ======== IPC_threadGeneratedReset ========
*/
Void IPC_threadGeneratedReset()
{
Int status;
UInt16 masterId;
masterId = MultiProc_getId("HOST");
do {
status = Ipc_detach(masterId);
} while (status < 0);
do {
status = Ipc_stop();
} while (status < 0);
do {
status = Ipc_start();
} while (status < 0);
}
/*
* ======== Interrupt_Module_startup ========
*/
Int Interrupt_Module_startup(Int phase)
{
volatile UInt32 *kick0 = (volatile UInt32 *)Interrupt_KICK0;
volatile UInt32 *kick1 = (volatile UInt32 *)Interrupt_KICK1;
UInt16 procId = MultiProc_self();
/*
* If this assert fails, the MultiProc config has changed to break
* an assumption in Linux rpmsg driver, that HOST is listed first in
* MultiProc ID configuration.
*/
Assert_isTrue(0 == MultiProc_getId("HOST"), NULL);
/*
* Wait for Startup to be done (if MultiProc id not yet set) because a
* user fxn should set it
*/
if (!Startup_Module_startupDone() && procId == MultiProc_INVALIDID) {
return (Startup_NOTDONE);
}
if (!Interrupt_enableKick) {
/* Do not unlock the kick registers */
return (Startup_DONE);
}
/*
* Only write to the KICK registers if:
* - This core is the SR0 owner
* - There is no SR0 and this core has procId '1' (IPC 3.x: this case).
*/
/* TODO: What if CORE0 is not started, but the others are? */
if (DNUM == 0) {
if (Interrupt_KICK0 && Interrupt_KICK1){
/* unlock the KICK mechanism in the Bootcfg MMRs if defined */
kick0[0] = 0x83e70b13; /* must be written with this value */
kick1[0] = 0x95a4f1e0; /* must be written with this value */
}
}
return (Startup_DONE);
}
/*
* ======== tsk0_func ========
* Send an interrupt to the DSP processor and wait on semaphore.
*/
Void tsk0_func(UArg arg0, UArg arg1)
{
Int i = 1;
Int status;
Int16 remoteProcId = MultiProc_getId("DSP");
while (i <= NUMLOOPS) {
/* Send an event to the DSP */
status = Notify_sendEvent(dspProcId, LINE_0, EVENTID, i, TRUE);
/* Continue until remote side is up */
if (status < 0) {
continue;
}
System_printf("Sent request #%d to DSP (lineId = 0)\n", i);
/* Wait to be released by the cbFxn posting the semaphore */
Semaphore_pend(semHandle, BIOS_WAIT_FOREVER);
System_printf("Received request #%d from DSP (lineId = 1)\n", seq);
/* Send an event to the DSP */
status = Notify_sendEvent(dspProcId, LINE_1, EVENTID, i, TRUE);
/* Continue until remote side is up */
if (status < 0) {
continue;
}
System_printf("Sent request #%d to DSP (lineId = 1)\n", i);
/* Wait to be released by the cbFxn posting the semaphore */
Semaphore_pend(semHandle, BIOS_WAIT_FOREVER);
System_printf("Received request #%d from DSP (lineId = 0)\n", seq);
/* increment for next iteration */
i++;
}
System_printf("Test completed\n");
BIOS_exit(0);
}