/*
* ======== DSKT2_deactivateAll ========
*/
Int DSKT2_deactivateAll()
{
#ifndef DSKT2_DISABLELAZYD
IALG_Handle alg;
Int i;
#endif
Int nActive = 0;
Log_print0(Diags_ENTRY, "[+E] DSKT2_deactivateAll Enter");
#ifndef DSKT2_DISABLELAZYD
if (_DSKT2_lastActiveAlg == NULL) {
/*
* Memory not yet allocated for _DSKT2_lastActiveAlg ( _DSKT2_init not
* yet called), so return "0" active algorithms
*/
return (nActive);
}
/*
* Deactivate all algs that have been lazily deactivated.
*/
for (i = 0; i < DSKT2_NUM_SCRATCH_GROUPS; i++) {
if ((alg = _DSKT2_lastActiveAlg[i]) != NULL) {
if (alg->fxns->algDeactivate != NULL) {
Log_print2(Diags_USER4,
"[+4] DSKT2_deactivateAll> Real deactivate of algorithm "
"0x%x in scratch group %d", (IArg)alg, (IArg)i);
alg->fxns->algDeactivate(alg);
}
_DSKT2_lastActiveAlg[i] = NULL;
}
if (_DSKT2_activeAlg[i] != NULL) {
Log_print2(Diags_USER2, "[+2] DSKT2_deactivateAll>"
" Algorithm 0x%x in scratch group %d still active",
(IArg)alg, (IArg)i);
nActive++;
}
}
#endif
Log_print1(Diags_EXIT, "[+X] DSKT2_deactivateAll Exit (numActive=%d)",
(IArg)(nActive + _DSKT2_NumYielded));
return (nActive + _DSKT2_NumYielded);
}
Int RcmClient_removeSymbol(RcmClient_Object *obj, String name)
{
// Int status = RcmClient_S_SUCCESS;
Int status = RcmClient_E_FAIL;
Log_print2(Diags_ENTRY, "--> %s: (obj=0x%x)", (IArg)FXNN, (IArg)obj);
/* TODO */
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
Int RcmClient_alloc(RcmClient_Object *obj, UInt32 dataSize,
RcmClient_Message **message)
{
SizeT totalSize;
RcmClient_Packet *packet;
Int status = RcmClient_S_SUCCESS;
Log_print3(Diags_ENTRY,
"--> RcmClient_alloc: obj: 0x%x, dataSize: %d, message: 0x%x",
(IArg)obj, (IArg)dataSize, (IArg)message);
/* ensure minimum size of UInt32[1] */
dataSize = (dataSize < sizeof(UInt32) ? sizeof(UInt32) : dataSize);
/* total memory size (in chars) needed for headers and payload */
totalSize = sizeof(RcmClient_Packet) - sizeof(UInt32) + dataSize;
/* allocate the message */
packet = (RcmClient_Packet*)MessageQ_alloc(obj->heapId, totalSize);
if (NULL == packet) {
Log_error1(FXNN": could not allocate message, size = %u",
(IArg)totalSize);
status = RcmClient_E_MSGALLOCFAILED;
goto leave;
}
/* Log_info() */
Log_print2(Diags_INFO,
FXNN": RcmMessage allocated: addr=0x%x, size=%u (total size)",
(IArg)packet, (IArg)totalSize);
/* initialize the packet structure */
packet->desc = 0;
packet->msgId = RcmClient_genMsgId_P(obj);
packet->message.poolId = RcmClient_DEFAULTPOOLID;
packet->message.jobId = RcmClient_DISCRETEJOBID;
packet->message.fxnIdx = RcmClient_INVALIDFXNIDX;
packet->message.result = 0;
packet->message.dataSize = dataSize;
/* set message pointer to start of the message struct */
*message = (RcmClient_Message *)(&(packet->message));
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
/*
* ======== VIDDEC2_processAsync ========
*/
XDAS_Int32 VIDDEC2FRONT_processAsync(VIDDEC2_Handle handle,
VIDDEC2_InArgs *inArgs, XDM_Context *context,
VIDDEC2FRONT_OutArgs *outArgs)
{
XDAS_Int32 retVal = VIDDEC2_EFAIL;
/*
* Note, we do this because someday we may allow dynamically changing
* the global 'VISA_isChecked()' value on the fly. If we allow that,
* we need to ensure the value stays consistent in the context of this call.
*/
Bool checked = VISA_isChecked();
Log_print4(Diags_ENTRY, "[+E] VIDDEC2_processAsync> "
"Enter (handle=0x%x, inArgs=0x%x, context=0x%x, outArgs=0x%x)",
(IArg)handle, (IArg)inArgs, (IArg)context, (IArg)outArgs);
if (handle) {
IVIDDEC2FRONT_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/* validate inArgs with ranges. */
if (inArgs->inputID == 0) {
Log_print2(Diags_USER7,
"[+7] ERROR> app provided codec (0x%x) with out of range "
"inArgs->inputID field (0x%x)",
(IArg)alg, (IArg)(inArgs->inputID));
}
#if 0
/*
* Validate inBufs and outBufs.
*/
XdmUtils_validateSparseBufDesc1(inBufs, "inBufs");
XdmUtils_validateSparseBufDesc(outBufs, "outBufs");
#endif
}
retVal = processAsync(alg, inArgs, context, outArgs);
}
}
Log_print2(Diags_EXIT, "[+X] VIDDEC2FRONT_processAsync> "
"Exit (handle=0x%x, retVal=0x%x)", (IArg)handle, (IArg)retVal);
return (retVal);
}
Int RcmClient_waitUntilDone(RcmClient_Object *obj,
UInt16 msgId, RcmClient_Message **returnMsg)
{
RcmClient_Message *rtnMsg;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print4(Diags_ENTRY, "--> %s: (obj=0x%x, msgId=%d, msg=0x%x)",
(IArg)FXNN, (IArg)obj, (IArg)msgId, (IArg)returnMsg);
/* get the return message from the server */
rval = RcmClient_getReturnMsg_P(obj, msgId, &rtnMsg);
if (rval < 0) {
*returnMsg = NULL;
status = rval;
goto leave;
}
*returnMsg = rtnMsg;
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
/*
* ======== Memory_redefine ========
*/
Bool ti_sdo_ce_osal_Memory_redefine(Int segId, Uint32 base, Uint32 size)
{
HeapMem_Params params;
HeapMem_Handle heap;
Memory_Stat stat;
if ((segId < 0) || (segId >= Memory_numHeaps)) {
Log_print2(Diags_USER7, "Memory_redefine> segId (%d) out of range. "
"Should be < %d", (IArg)segId,
(IArg)Memory_numHeaps);
return (FALSE);
}
if (!Memory_segStat(segId, &stat)) {
Log_print0(Diags_USER7, "Memory_redefine> Memory_segStat() failed!");
return (FALSE);
}
if (stat.used > 0) {
Log_print0(Diags_USER7, "Memory_redefine> Heap in use!");
return (FALSE);
}
heap = ti_sdo_ce_osal_Memory_heapList[segId];
HeapMem_destruct(HeapMem_struct(heap));
HeapMem_Params_init(¶ms);
params.size = size;
params.buf = (Ptr)base;
HeapMem_construct(HeapMem_struct(heap), ¶ms);
return (TRUE);
}
/*
* ======== Loader_getSymbol ========
*/
UInt32 Loader_getSymbol(Loader_Handle lib, String name)
{
Void *sym = NULL;
String errString = NULL;
Log_print2(Diags_ENTRY, "[+E] Loader_getSymbol(0x%lx, %s)",
(IArg)lib, (IArg)name);
sym = dlsym(lib->handle, name);
if (sym == NULL) {
Log_print1(Diags_USER6, "[+6] Loader_getSymbol(): %s failed",
(IArg)name);
errString = (String)dlerror();
if (errString != NULL) {
Log_print1(Diags_USER7, "[+7] Loader_getSymbol> dlsym() error: %s",
(IArg)errString);
}
}
Log_print1(Diags_EXIT, "[+X] Loader_getSymbol> Returning 0x%x", (IArg)sym);
return ((UInt32)sym);
}
/*
* ======== WatchdogCC26XX_setReload ========
*/
void WatchdogCC26XX_setReload(Watchdog_Handle handle, uint32_t value)
{
WatchdogCC26XX_Object *object;
/* get the pointer to the object and hwAttrs */
object = handle->object;
/* udpate the watchdog object with the new reload value */
object->reloadValue = value;
/* unlock the Watchdog configuration registers */
WatchdogUnlock();
/* make sure the Watchdog is unlocked before continuing */
while(WatchdogLockState() == WATCHDOG_LOCK_LOCKED)
{ }
/* update the reload value */
WatchdogReloadSet(object->reloadValue);
/* lock register access */
WatchdogLock();
Log_print2(Diags_USER1, "Watchdog: WDT with handle 0x%x has been set to "
"reload to 0x%x", (UArg)handle, value);
}
/*!
* ======== InterruptM3_intSend ========
* Send interrupt to the remote processor
*/
Void InterruptM3_intSend(UInt16 remoteProcId, UArg arg)
{
Log_print2(Diags_USER1,
"InterruptM3_intSend: Sending interrupt with payload 0x%x to proc #%d",
(IArg)arg, (IArg)remoteProcId);
if (remoteProcId == sysm3ProcId) {
while(REG32(MAILBOX_FIFOSTATUS(SYSM3_MBX)));
REG32(MAILBOX_MESSAGE(SYSM3_MBX)) = arg;
}
else if (remoteProcId == appm3ProcId) {
while(REG32(MAILBOX_FIFOSTATUS(APPM3_MBX)));
/* Write to the mailbox, but this won't trigger an interrupt */
REG32(MAILBOX_MESSAGE(APPM3_MBX)) = arg;
/* Actually trigger the interrupt */
REG16(INTERRUPT_CORE_1) |= 0x1;
}
else if (remoteProcId == dspProcId) {
while(REG32(MAILBOX_FIFOSTATUS(DSP_MBX)));
REG32(MAILBOX_MESSAGE(DSP_MBX)) = arg;
}
else if (remoteProcId == hostProcId) {
while(REG32(MAILBOX_FIFOSTATUS(HOST_MBX)));
REG32(MAILBOX_MESSAGE(HOST_MBX)) = arg;
}
else {
/* Should never get here */
Assert_isTrue(FALSE, NULL);
}
}
/*
* ======== doCmd ========
*/
static Int doCmd(Int cmdId, Processor_Handle proc)
{
Int result;
IArg key;
Log_print2(Diags_ENTRY, "[+E] doCmd> Enter (cmdId=%d, proc=0x%x)",
(IArg)cmdId, (IArg)proc);
//pthread_mutex_lock(&dcmd.gate);
key = GateThread_enter(dcmd.gate);
dcmd.proc = proc;
dcmd.cmdId = cmdId;
//pthread_cond_signal(&dcmd.cmdPresent);
SemThread_post(dcmd.cmdPresent, NULL);
//while (dcmd.reply == NONE) {
// pthread_cond_wait(&dcmd.replyPresent, &dcmd.gate);
//}
SemThread_pend(dcmd.replyPresent, SemThread_FOREVER, NULL);
result = dcmd.reply;
dcmd.reply = NONE;
//pthread_mutex_unlock(&dcmd.gate);
GateThread_leave(dcmd.gate, key);
Log_print1(Diags_EXIT, "[+X] doCmd> Exit (result=%d)", (IArg)result);
return (result);
}
/*
* ======== VIDENCCOPY_TI_dmaGetChannels ========
* Declare DMA resource requirement/holdings.
*/
Uns VIDENCCOPY_TI_dmaGetChannels(IALG_Handle handle, IDMA3_ChannelRec dmaTab[])
{
VIDENCCOPY_TI_Obj *videncObj = (Void *)handle;
int i;
Log_print2(Diags_ENTRY, "[+E] VIDENCCOPY_TI_dmaGetChannels(0x%x, 0x%x)",
(IArg)handle, (IArg)dmaTab);
/* Initial values on logical channels */
dmaTab[0].handle = videncObj->dmaHandle1D1D8B;
dmaTab[0].numTransfers = 1;
dmaTab[0].numWaits = 1;
/*
* Request logical DMA channels for use with ACPY3
* AND with environment size obtained from ACPY3 implementation
* AND with low priority.
*/
for (i = 0; i < NUM_LOGICAL_CH; i++) {
dmaTab[i].priority = IDMA3_PRIORITY_LOW;
dmaTab[i].persistent = FALSE;
dmaTab[i].protocol = &ACPY3_PROTOCOL;
}
return (NUM_LOGICAL_CH);
}
Int RcmClient_construct(RcmClient_Struct *structPtr, String server,
const RcmClient_Params *params)
{
RcmClient_Object *obj = (RcmClient_Object*)structPtr;
Int status = RcmClient_S_SUCCESS;
Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN);
/* TODO: add check that params was initialized correctly */
Log_print1(Diags_LIFECYCLE, FXNN": instance construct: 0x%x", (IArg)obj);
/* ensure the constructed object is zeroed */
_memset((Void *)obj, 0, sizeof(RcmClient_Object));
/* object-specific initialization */
status = RcmClient_Instance_init(obj, server, params);
if (status < 0) {
RcmClient_Instance_finalize(obj);
goto leave;
}
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
/* ARGSUSED - this line tells the compiler not to warn about unused args. */
IRES_Status IRES_HDVICP2_getMemRecs(IRES_Handle handle,
IRES_ProtocolArgs * resProtocolArgs, IALG_MemRec *memRecs)
{
Assert_isTrue(memRecs != NULL, (Assert_Id)NULL);
Assert_isTrue(resProtocolArgs != NULL, (Assert_Id)NULL);
Log_print3(Diags_ENTRY,
"[+E] IRES_HDVICP2_getMemRecs> Enter (handle=0x%x, "
"resProtocolArgs=0x%x, memRecs=0x%x)",
(IArg)handle, (IArg)resProtocolArgs, (IArg)memRecs);
memRecs[0].alignment = 4;
memRecs[0].size = sizeof(IRES_HDVICP2_IntObj);
/*
* IALG_EXTERNAL because we don't care where this memory is allocated
*/
memRecs[0].space = IALG_EXTERNAL;
/*
* Memory should be persistent.
*/
memRecs[0].attrs = IALG_PERSIST;
Log_print2(Diags_USER4,
"[+4] IRES_HDVICP2_getMemRecs> Amount of memory requested 0x%x, "
"alignment 0x%x, space IALG_EXTERNAL attrs IALG_PERSIST",
(IArg)(memRecs[0].size), (IArg)(memRecs[0].alignment));
Log_print0(Diags_EXIT,
"[+X] IRES_HDVICP2_getMemRecs> Exit (status=IRES_EOK)");
return (IRES_OK); /* number of MemRecs */
}
/*
* ======== Memory_free ========
*/
Bool Memory_free(Ptr addr, UInt size, Memory_AllocParams *params)
{
Log_print2(Diags_ENTRY, "[+E] Memory_free(0x%lx, 0x%lx)",
(IArg)addr, (IArg)size);
return (Memory_segFree(DEFAULTSEGMENT, addr, size));
}
/*
* ======== RMAN_exit ========
* Exit the generic IRES RMAN and free the memory back to the Memory manager
* using which it was created.
*/
IRES_Status RMAN_exit()
{
IArg key;
Int i;
IRES_Status status = IRES_OK;
if (rmanInit == 0) {
return (IRES_ENOINIT);
}
Log_print0(Diags_ENTRY, "[+E] RMAN_exit> Enter ");
rmanInternalState->info.refCount--;
if (--rmanInit == 0) {
if (initStatus != IRES_OK) {
Log_print0(Diags_USER7, "[+7] RMAN_exit> RMAN_init call didn't "
"happen successfully. RMAN_exit will not unregister "
"any resources.");
status = IRES_ENOINIT;
}
else {
key = IGateProvider_enter(gate);
Log_print1(Diags_EXIT, "[+X] RMAN_exit> tableIndex = %d",
(IArg)(resTable.tableIndex));
/* Unregister the entries */
Log_print0(Diags_EXIT, "[+X] RMAN_exit> Unregistering resources");
for (i = 0; i < resTable.tableIndex; i++) {
if (RMAN_TABLE[i] != NULL) {
/* Even if there is an error, unregister the rest */
if ((status = RMAN_TABLE[i]->exit()) != IRES_OK) {
Log_print2(Diags_USER7, "[+7] RMAN_exit> Error "
"unregistering the IRESMAN implementation "
"0x%x, status = %d",
(IArg)(RMAN_TABLE[i]), (IArg)status);
status = IRES_EFAIL;
}
}
}
/* Free the RMAN object */
freeInternalState();
initStatus = IRES_ENOINIT;
/* Free the gate after leaving it */
IGateProvider_leave(gate, key);
OsalSupport_deleteGate(gate);
gate = NULL;
}
}
Log_print1(Diags_EXIT, "[+X] RMAN_exit> Exit (status=%d)", (IArg)status);
return (status);
}
/*
* ======== Memory_contigAlloc ========
*/
Ptr Memory_contigAlloc(UInt size, UInt align)
{
Log_print2(Diags_ENTRY, "[+E] Memory_contigAlloc(0x%lx, 0x%lx)",
(IArg)size, (IArg)align);
return (Memory_segAlloc(DEFAULTSEGMENT, size, align));
}
/*
* ======== Memory_contigFree ========
*/
Bool Memory_contigFree(Ptr addr, UInt size)
{
Log_print2(Diags_ENTRY, "[+E] Memory_contigFree(0x%lx, 0x%lx)",
(IArg)addr, (IArg)size);
return (Memory_segFree(DEFAULTSEGMENT, addr, size));
}
/*
* ======== USBMSCHFatFsTiva_diskWrite ========
* This function writes sector(s) to the disk drive
*
* @param drv Drive Number
*
* @param buf Pointer to a buffer from which data is read
*
* @param sector Sector number to write to
*
* @param count Number of sectors to be written
*/
DRESULT USBMSCHFatFsTiva_diskWrite(BYTE drv, const BYTE *buf,
DWORD sector, BYTE count)
{
unsigned int key;
uint32_t driveWrite;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
Log_print2(Diags_USER1, "USBMSCHFatFs: diskWrite: Sector %d, Count %d",
sector, count);
if (!count) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskWrite: ERROR");
return (RES_PARERR);
}
if (object->state != USBMSCHFatFsTiva_CONNECTED) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskWrite: not initialized");
return (RES_NOTRDY);
}
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
driveWrite = USBHMSCBlockWrite(object->MSCInstance, sector, (uint8_t *)buf, count);
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
if (driveWrite == 0) {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskWrite: OK");
return (RES_OK);
}
else {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskWrite: ERROR");
return (RES_ERROR);
}
}
/*
* ======== VIDDEC2_processAsync ========
*/
XDAS_Int32 VIDDEC2BACK_processAsync(VIDDEC2FRONT_Handle handle,
XDM_Context *context, VIDDEC2_OutArgs *outArgs)
{
XDAS_Int32 retVal = VIDDEC2_EFAIL;
/*
* Note, we do this because someday we may allow dynamically changing
* the global 'VISA_isChecked()' value on the fly. If we allow that,
* we need to ensure the value stays consistent in the context of this call.
*/
Bool checked = VISA_isChecked();
Log_print4(Diags_ENTRY, "[+E] VIDDEC2BACK_processAsync> "
"Enter (handle=0x%x, context=0x%x outArgs=0x%x (size=0x%x))",
(IArg)handle, (IArg)context, (IArg)outArgs,
(IArg)(outArgs->size));
if (handle) {
IVIDDEC2BACK_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/* validate context */
}
retVal = processAsync(alg, context, outArgs);
}
}
Log_print2(Diags_EXIT, "[+X] VIDDEC2BACK_processAsync> "
"Exit (handle=0x%x, retVal=0x%x)", (IArg)handle, (IArg)retVal);
return (retVal);
}
/*
* ======== USBMSCHFatFsTiva_diskRead ========
* This function reads sector(s) from the disk drive
*
* @param drv Drive Number
*
* @param buf Pointer to a buffer to which data is written
*
* @param sector Sector number to read from
*
* @param count Number of sectors to be read
*/
DRESULT USBMSCHFatFsTiva_diskRead(BYTE drv, BYTE *buf,
DWORD sector, BYTE count)
{
unsigned int key;
uint32_t driveRead;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
Log_print2(Diags_USER1, "USBMSCHFatFs: diskRead: Sector %d, Count %d",
sector, count);
if (object->state != USBMSCHFatFsTiva_CONNECTED) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskRead: not initialized");
return (RES_NOTRDY);
}
/* READ BLOCK */
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
driveRead = USBHMSCBlockRead(object->MSCInstance, sector, buf, count);
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
if (driveRead == 0) {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskRead: OK");
return (RES_OK);
}
else {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskRead: ERROR");
return (RES_ERROR);
}
}
Int RcmClient_execCmd(RcmClient_Object *obj, RcmClient_Message *msg)
{
RcmClient_Packet *packet;
MessageQ_Msg msgqMsg;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY | Diags_INFO,
"--> "FXNN": (obj=0x%x, msg=0x%x)", (IArg)obj, (IArg)msg);
/* classify this message */
packet = RcmClient_getPacketAddr_P(msg);
packet->desc |= RcmClient_Desc_CMD << RcmClient_Desc_TYPE_SHIFT;
/* set the return address to the error message queue */
msgqMsg = (MessageQ_Msg)packet;
MessageQ_setReplyQueue(obj->errorMsgQue, msgqMsg);
/* send the message to the server */
rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);
if (rval < 0) {
Log_error0(FXNN": unable to send message to server");
status = RcmClient_E_IPCERROR;
}
Log_print1(Diags_EXIT | Diags_INFO, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== Comm_create ========
*/
Comm_Handle Comm_create(String queueName, Comm_Attrs *attrs)
{
Comm_Obj *comm;
UInt32 commId;
Char commName[ MAXCOMMNAMELEN ];
key_t key;
Assert_isTrue(curInit > 0, (Assert_Id)NULL);
Log_print2(Diags_ENTRY, "[+E] Comm_create> "
"Enter(queueName='%s', attrs=0x%x)", (IArg)queueName, (IArg)attrs);
if (attrs == NULL) {
attrs = &Comm_ATTRS;
}
if (queueName == NULL) {
/* Generate a name to use */
// TODO: Increment curCommId atomically
commId = curCommId++;
sprintf(commName, "queue_%lu_%u", Global_getProcessId(), (Uns)commId);
key = nameToId(commName);
}
else {
key = nameToId(queueName);
}
comm = (Comm_Obj *)Memory_alloc(NULL, sizeof(Comm_Obj), 0, NULL);
if (comm == NULL) {
return (NULL);
}
comm->type = attrs->type;
if (comm->type == Comm_PEND) {
;
}
else if (comm->type == Comm_CALL) {
comm->callHandle = attrs->callHandle;
comm->callFxn = attrs->callFxn;
}
else {
Assert_isTrue(FALSE, (Assert_Id)NULL); /* unknown Comm type */
}
/*
* Create a new message queue id for the "name" key
*/
if ((comm->id = msgget(key, IPC_CREAT | 0644)) < 0) {
fprintf(stderr, "msgget key = 0x%x\n", key);
perror("Comm_create:msgget");
Memory_free(NULL, comm, sizeof(Comm_Obj));
return (NULL);
}
Log_print1(Diags_EXIT, "[+X] Comm_create> return (0x%x)", (IArg)comm);
return (comm);
}
/*
* ======== Memory_getBufferVirtualAddress ========
* TODO:H - for multicore devices, we probably need to implement a GLOB_TO_LOC!
*/
Ptr Memory_getBufferVirtualAddress(
UInt32 physicalAddress, Int sizeInBytes)
{
Log_print2(Diags_ENTRY, "[+E] Memory_getBufferVirtualAddress(0x%x, 0x%x)",
(IArg)physicalAddress, (IArg)sizeInBytes);
return ((Ptr)physicalAddress);
}
/*
* ======== UNIVERSAL_processAsync ========
*/
XDAS_Int32 UNIVERSAL_processAsync(UNIVERSAL_Handle handle,
XDM1_BufDesc *inBufs, XDM1_BufDesc *outBufs, XDM1_BufDesc *inOutBufs,
IUNIVERSAL_InArgs *inArgs, IUNIVERSAL_OutArgs *outArgs)
{
XDAS_Int32 retVal = UNIVERSAL_EFAIL;
/*
* Note, we assign "VISA_isChecked()" results to a local variable
* rather than repeatedly query it throughout this fxn because
* someday we may allow dynamically changing the global
* 'VISA_isChecked()' value on the fly. If we allow that, we need
* to ensure the value stays consistent in the context of this
* call.
*/
Bool checked = VISA_isChecked();
Log_print5(Diags_ENTRY, "[+E] UNIVERSAL_processAsync> "
"Enter (handle=0x%x, inBufs=0x%x, outBufs=0x%x, inArgs=0x%x, "
"outArgs=0x%x)",
(IArg)handle, (IArg)inBufs, (IArg)outBufs, (IArg)inArgs,
(IArg)outArgs);
if (handle) {
IUNIVERSAL_Handle alg = VISA_getAlgHandle((VISA_Handle)handle);
if (alg != NULL) {
if (checked) {
/* validate inArgs and outArgs */
XdmUtils_validateExtendedStruct(inArgs, sizeof(inArgs),
"inArgs");
XdmUtils_validateExtendedStruct(outArgs, sizeof(outArgs),
"outArgs");
/* Validate inBufs and outBufs. */
XdmUtils_validateSparseBufDesc1(inBufs, "inBufs");
XdmUtils_validateSparseBufDesc1(outBufs, "outBufs");
/*
* Zero out the outArgs struct (except for .size field);
* it's write-only to the codec, so the app shouldn't pass
* values through it, nor should the codec expect to
* receive values through it.
*/
memset((void *)((XDAS_Int32)(outArgs) + sizeof(outArgs->size)),
0, (sizeof(*outArgs) - sizeof(outArgs->size)));
}
retVal = processAsync(alg, inBufs, outBufs, inOutBufs, inArgs,
outArgs);
}
}
Log_print2(Diags_EXIT, "[+X] UNIVERSAL_processAsync> "
"Exit (handle=0x%x, retVal=0x%x)", (IArg)handle, (IArg)retVal);
return (retVal);
}
Int SystemCfg_closeSharedResources(SystemCfg_AppFxn appShutdownFxn, Ptr arg)
{
Error_Block eb;
Int status = 0;
struct SystemCfg *stateObj = &SystemCfg_State;
Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN);
Error_init(&eb);
/* invoke the application shutdown function */
if (appShutdownFxn != NULL) {
status = appShutdownFxn(arg);
if (status < 0) {
goto leave;
}
}
/* close shared resources from remote core */
/* <add code here> */
/* send close done event to remote core */
Log_print0(Diags_USER1, FXNN": send EvtCloseDone to remote core");
status = Notify_sendEvent(stateObj->hostProcId, Global_NotifyLineId,
Global_HostDspEvtNum, Global_EvtCloseDone, TRUE);
if (status < 0) {
/* Log_error() */
Log_print4(Diags_USER8,
"Error: %s, line %d: %s: Notify_sendEvent() returned error %d",
(IArg)__FILE__, (IArg)__LINE__, (IArg)FXNN, (IArg)status);
goto leave;
}
/* wait for close event from remote core */
Log_print0(Diags_USER1, FXNN": waiting for EvtCloseDone 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 EvtCloseDone event");
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
/*
* ======== Memory_cacheWbInv ========
*/
Void Memory_cacheWbInv(Ptr addr, Int sizeInBytes)
{
Log_print2(Diags_ENTRY, "[+E] Memory_cacheWbInv> "
"Enter(addr=0x%x, sizeInBytes=%d)", (IArg)addr, (IArg)sizeInBytes);
Cache_wbInv(addr, sizeInBytes, Cache_Type_ALL, TRUE);
Log_print0(Diags_EXIT, "[+X] Memory_cacheWbInv> return");
}
/*
* ======== Algorithm_releaseLock ========
*/
Void Algorithm_releaseLock(Int groupId, IALG_Handle alg)
{
Log_print2(Diags_ENTRY, "[+E] Algorithm_releaseLock> Enter(alg=0x%x,"
" groupId=%d)", (IArg)alg, (IArg)groupId);
Log_print0(Diags_ENTRY, "[+E] Algorithm_releaseLock> Feature not "
"supported on BIOS (yet).");
Log_print0(Diags_EXIT, "[+X] Algorithm_releaseLock> Exit");
}
/*
* ======== VIDENCCOPY_TI_dmaChangeChannels ========
* Update instance object with new logical channel.
*/
Void VIDENCCOPY_TI_dmaChangeChannels(IALG_Handle handle,
IDMA3_ChannelRec dmaTab[])
{
VIDENCCOPY_TI_Obj *videncObj = (Void *)handle;
Log_print2(Diags_ENTRY, "[+E] VIDENCCOPY_TI_dmaChangeChannels(0x%x, 0x%x)",
(IArg)handle, (IArg)dmaTab);
videncObj->dmaHandle1D1D8B = dmaTab[0].handle;
}
/*
* ======== getVirtualAddress ========
*/
static UInt32 getVirtualAddress(UInt32 physicalAddress, UInt32 sizeInBytes)
{
UInt32 virtualAddress = 0;
ContigBuf *cb;
Log_print2(Diags_USER1, "[+1] Memory__getVirtualAddress> "
"Enter(physAddr=0x%x, size=0x%x)",
(IArg)physicalAddress, (IArg)sizeInBytes);
for (cb = contigBufList; cb != NULL; cb = cb->next) {
UInt32 startCurrent = cb->physicalAddress;
UInt32 endCurrent = startCurrent + cb->sizeInBytes;
UInt32 startSubmitted = physicalAddress;
UInt32 endSubmitted = physicalAddress + sizeInBytes;
/* check if the submitted contigbuf is a subset of the current
* contigbuf.
*/
if (startCurrent <= startSubmitted &&
endCurrent >= endSubmitted) { /* case 1: { [ ] } */
Log_print4(Diags_USER1, "[+1] Memory__getVirtualAddress> "
"found in cb(Sc=0x%x, Ec=0x%x, Ss=0x%x, Es=0x%x)",
(IArg)startCurrent, (IArg)endCurrent, (IArg)startSubmitted,
(IArg)endSubmitted);
virtualAddress = cb->virtualAddress + startSubmitted - startCurrent;
break; /* result: ^ */
}
}
if (virtualAddress == 0) {
Log_print2(Diags_USER7, "[+7] Memory_getVirtualAddress> "
"ERROR: buffer (physAddr=0x%x, size=0x%x) not found in translation"
"cache\n\nEnsure that you have registered this buffer with "
"Memory_registerContigBuf()\n", (IArg)physicalAddress, (IArg)sizeInBytes);
}
Log_print1(Diags_USER1, "[+1] Memory__getVirtualAddress> "
"returning virtAddr=0x%x", (IArg)virtualAddress);
return (virtualAddress);
}
/*
* ======== Memory_contigFree ========
*/
Bool Memory_contigFree(Ptr addr, UInt size)
{
Log_print2(Diags_ENTRY, "[+E] Memory_contigFree> "
"Enter(addr=0x%x, size=%d)", (IArg)addr, (IArg)size);
segFree(xdc_runtime_Memory_defaultHeapInstance, addr, size);
Log_print0(Diags_EXIT, "[+X] Memory_contigFree> Exit");
return (TRUE);
}
