/*
* ======== Timer_getStatus ========
*/
Timer_Status Timer_getStatus(UInt timerId)
{
Assert_isTrue(timerId < Timer_NUM_TIMER_DEVICES, NULL);
if (Timer_module->availMask & (0x1 << timerId)) {
return (Timer_Status_FREE);
}
else {
return (Timer_Status_INUSE);
}
}
/*!
* ======== InterruptDsp_intDisable ========
* Disables remote processor interrupt
*/
Void InterruptDsp_intDisable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
{
UInt16 index;
Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&
(remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
index = MBX_TABLE_IDX(remoteProcId, MultiProc_self());
REG32(MAILBOX_IRQENABLE_CLR_DSP(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));
}
/*!
* ======== InterruptDsp_intRegister ========
*/
Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
Fxn func, UArg arg)
{
UInt key;
UInt eventId;
UInt combinedEventId;
Int index;
Hwi_Params params;
InterruptDsp_FxnTable *table;
Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&
(remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);
index = PROCID(remoteProcId);
/* Disable global interrupts */
key = Hwi_disable();
table = &(InterruptDsp_module->fxnTable[index]);
table->func = func;
table->arg = arg;
InterruptDsp_intClear(remoteProcId, intInfo);
/* Make sure the interrupt only gets plugged once */
eventId = InterruptDsp_dspInterruptTable[index];
InterruptDsp_module->numPlugged++;
if (InterruptDsp_module->numPlugged == 1) {
EventCombiner_dispatchPlug(eventId,
(Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);
Hwi_Params_init(¶ms);
combinedEventId = eventId / EVENT_GROUP_SIZE;
params.eventId = combinedEventId;
params.arg = combinedEventId;
params.enableInt = TRUE;
Hwi_create(intInfo->intVectorId, &ti_sysbios_family_c64p_EventCombiner_dispatch,
¶ms, NULL);
Hwi_enableInterrupt(intInfo->intVectorId);
}
else {
EventCombiner_dispatchPlug(eventId,
(Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);
}
/* Enable the mailbox interrupt to the DSP */
InterruptDsp_intEnable(remoteProcId, intInfo);
/* Restore global interrupts */
Hwi_restore(key);
}
/*
* ======== Event_post ========
*/
Void Event_post(Event_Object *event, UInt eventId)
{
UInt tskKey, hwiKey;
Event_PendElem *elem;
Queue_Handle pendQ;
Assert_isTrue((eventId != 0), Event_A_nullEventId);
Log_write3(Event_LM_post, (UArg)event, (UArg)event->postedEvents, (UArg)eventId);
pendQ = Event_Instance_State_pendQ(event);
/* atomically post this event */
hwiKey = Hwi_disable();
/* or in this eventId */
event->postedEvents |= eventId;
/* confirm that ANY tasks are pending on this event */
if (Queue_empty(pendQ)) {
Hwi_restore(hwiKey);
return;
}
tskKey = Task_disable();
/* examine pendElem on pendQ */
elem = (Event_PendElem *)Queue_head(pendQ);
/* check for match, consume matching eventIds if so. */
elem->matchingEvents = Event_checkEvents(event, elem->andMask, elem->orMask);
if (elem->matchingEvents != 0) {
/* remove event elem from elem queue */
Queue_remove((Queue_Elem *)elem);
/* mark the Event as having been posted */
elem->pendState = Event_PendState_POSTED;
/* disable Clock object */
if (BIOS_clockEnabled && (elem->tpElem.clock != NULL)) {
Clock_stop(elem->tpElem.clock);
}
/* put task back into readyQ */
Task_unblockI(elem->tpElem.task, hwiKey);
}
Hwi_restore(hwiKey);
/* context switch may occur here */
Task_restore(tskKey);
}
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;
}
/*
* ======== 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);
}
/*
* ======== Timer_getStatus ========
* Get the FREE/INUSE status of the timer.
*/
Timer_Status Timer_getStatus(UInt timerId)
{
Assert_isTrue(timerId < Timer_numTimerDevices, NULL);
if (Timer_module->availMask & (0x1 << timerId)) {
return (Timer_Status_FREE);
}
else {
return (Timer_Status_INUSE);
}
}
/*
* ======== Algorithm_exit ========
*/
Void Algorithm_exit()
{
Assert_isTrue(curInit > 0, (Assert_Id)NULL);
if (--curInit == 0) {
ALG_exit();
DMAN3_CE_exit();
RMAN_exit();
}
}
/*
* ======== Timer_getHandle ========
*/
Timer_Handle Timer_getHandle(UInt id)
{
Assert_isTrue((id < Timer_NUM_TIMER_DEVICES), NULL);
if (id >= Timer_NUM_TIMER_DEVICES) {
return (NULL);
}
else {
return (Timer_module->handles[id]);
}
}
/*
* ======== Hwi_reconfig ========
* Reconfigure a dispatched interrupt.
*/
Void Hwi_reconfig(Hwi_Object *hwi, Hwi_FuncPtr fxn, const Hwi_Params *params)
{
UInt intNum;
Int priority;
for (intNum = 0; intNum < Hwi_NUM_INTERRUPTS; intNum++) {
if (Hwi_module->dispatchTable[intNum] == hwi) {
break;
}
}
Hwi_disableInterrupt(intNum);
hwi->fxn = fxn;
hwi->arg = params->arg;
priority = params->priority;
/*
* the -1 sentinel priority is the default passed by hal Hwi_create().
* Translate it to 31, which is our default priority.
*/
if (priority == -1) {
priority = 31;
}
Hwi_module->priorities[intNum] = priority;
Hwi_setPriority(intNum, priority);
Assert_isTrue((params->maskSetting != Hwi_MaskingOption_BITMASK),
Hwi_A_unsupportedMaskingOption);
switch (params->maskSetting) {
case Hwi_MaskingOption_NONE:
hwi->handler = Hwi_handlerNONE;
break;
case Hwi_MaskingOption_ALL:
hwi->handler = Hwi_handlerALL;
break;
case Hwi_MaskingOption_LOWER:
hwi->handler = Hwi_handlerLOWER;
break;
case Hwi_MaskingOption_BITMASK:
case Hwi_MaskingOption_SELF:
hwi->handler = Hwi_handlerSELF;
break;
}
if (params->enableInt) {
Hwi_enableInterrupt(intNum);
}
}
/*
* ======== DriverAdapter_reclaim ========
*/
Void DriverAdapter_reclaim(DriverAdapter_Object *obj,
DriverTypes_Packet **packet, Error_Block *eb)
{
List_Handle fromDriver;
fromDriver = DriverAdapter_Instance_State_fromDriver(obj);
/* Should never ever get this assert */
Assert_isTrue(!List_empty(fromDriver), DriverAdapter_A_noReadyPacket);
*packet = (DriverTypes_Packet *)List_get(fromDriver);
}
/*
* ======== IpcMgr_callIpcStart ========
* Initialize standard IPC module, which may use the RPMSG protocol as well.
*
* Calls the Ipc_start command. This must be done after IpcMgr_ipcStartup().
*
* Use for stacks using a combination of TransportRpmsg and other Transports.
*/
Void IpcMgr_callIpcStart()
{
Int status;
/*
* Ipc_start() calls Ipc_attach() to synchronize all remote processors
* if 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
* HOST is skipped, thanks to overriding NotifySetup_numIntLines().
*/
status = Ipc_start();
Assert_isTrue(status >= 0, NULL);
}
/*
* ======== Clock_Instance_finalize ========
*/
Void Clock_Instance_finalize(Clock_Object *obj)
{
UInt key;
Assert_isTrue(((BIOS_getThreadType() != BIOS_ThreadType_Hwi) &&
(BIOS_getThreadType() != BIOS_ThreadType_Swi)),
Clock_A_badThreadType);
key = Hwi_disable();
Queue_remove(&obj->elem);
Hwi_restore(key);
}
/*
* ======== Notify_attach ========
* Called within Ipc module or directly by the user
*/
Int Notify_attach(UInt16 remoteProcId, Ptr sharedAddr)
{
Int status;
Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors,
ti_sdo_ipc_Notify_A_invArgument);
/* Use the NotifySetup proxy to setup drivers */
status = ti_sdo_ipc_Notify_SetupProxy_attach(remoteProcId, sharedAddr);
return (status);
}
static void _ECPY_initEDMA3CHANStaticProperties(IRES_EDMA3CHAN2_Handle handle)
{
/* ensure that the toolchain uses same structure layout for PaRAM overlay */
Assert_isTrue((sizeof(IRES_EDMA3CHAN_PaRamStruct)==32), (Assert_Id)NULL);
if (_EDMA3_globalRegs == NULL) {
handle->ires.getStaticProperties((struct IRES_Obj *)handle,
(IRES_Properties *)&_EDMA3CHAN_staticProperties);
_EDMA3_globalRegs = _EDMA3CHAN_staticProperties.globalRegs;
}
}
/*
* ======== Notify_intLineRegistered ========
*/
Bool Notify_intLineRegistered(UInt16 procId, UInt16 lineId)
{
Bool registered;
UInt16 clusterId = ti_sdo_utils_MultiProc_getClusterId(procId);
Assert_isTrue(procId < ti_sdo_utils_MultiProc_numProcessors && lineId <
ti_sdo_ipc_Notify_numLines, ti_sdo_ipc_Notify_A_invArgument);
registered = (Notify_module->notifyHandles[clusterId][lineId] != NULL);
return (registered);
}
/*
* ======== Pmu_getOverflowStatus ========
*/
Bool Pmu_getOverflowStatus(UInt counterId)
{
Assert_isTrue((counterId < Pmu_module->numCounters),
Pmu_A_invalidCounterId);
if (Pmu_getOverflowStatusI(counterId)) {
return (TRUE);
}
else {
return (FALSE);
}
}
/*
* ======== processWait ========
*/
static XDAS_Int32 processWait(IVIDDEC2BACK_Handle h, XDM_Context *context,
IVIDDEC2_OutArgs *outArgs, UInt timeout)
{
XDAS_Int32 retVal;
_VIDDEC2BACK_Msg *msg;
VISA_Handle visa = (VISA_Handle)h;
Assert_isTrue(!VISA_isLocal(visa), (Assert_Id)NULL);
/* wait for completion of "last" message */
retVal = VISA_wait(visa, (VISA_Msg *)&msg, timeout);
Assert_isTrue(msg->visa.cmd == _VIDDEC2BACK_CPROCESS, (Assert_Id)NULL);
/*
* Regardless of return value, unmarshall outArgs.
*/
retVal = unmarshallMsg(h, context, outArgs, msg, retVal);
return (retVal);
}
/*
* ======== VIDENCCOPY_TI_alloc ========
*/
Int VIDENCCOPY_TI_alloc(const IALG_Params *algParams,
IALG_Fxns **pf, IALG_MemRec memTab[])
{
Registry_Result result;
/*
* No need to reference count for Registry_addModule(), since there
* is no way to remove the module.
*/
if (regInit == 0) {
/* Register this module for logging */
result = Registry_addModule(&ti_sdo_ce_examples_codecs_videnc_copy_desc,
MODNAME);
Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);
if (result == Registry_SUCCESS) {
/* Set the diags mask to the CE default */
CESettings_init();
CESettings_setDiags(MODNAME);
}
regInit = 1;
}
Log_print3(Diags_ENTRY, "[+E] VIDENCCOPY_TI_alloc(0x%x, 0x%x, 0x%x)",
(IArg)algParams, (IArg)pf, (IArg)memTab);
/* Request memory for my object */
memTab[0].size = sizeof(VIDENCCOPY_TI_Obj);
memTab[0].alignment = 0;
memTab[0].space = IALG_EXTERNAL;
memTab[0].attrs = IALG_PERSIST;
// ADD BY ZHENGHANG
memTab[1].size = sizeof(char)*25000 * 1024;
memTab[1].alignment = 0;
memTab[1].space = IALG_EXTERNAL;//IALG_DARAM0;
memTab[1].attrs = IALG_PERSIST;
// ADD BY ZHOULU
memTab[2].size = sizeof(char) * 150000 * 1024;
memTab[2].alignment = 0;
memTab[2].space = IALG_EXTERNAL;
memTab[2].attrs = IALG_PERSIST;
memTab[3].size = sizeof(char) * 127*1024;
memTab[3].alignment = 0;
memTab[3].space = IALG_DARAM0;
memTab[3].attrs = IALG_PERSIST;
//IALG_DARAM0;
return (4);
}
/*
* ======== Task_sleep ========
*/
Void Task_sleep(UInt timeout)
{
Task_PendElem elem;
UInt hwiKey, tskKey;
Clock_Struct clockStruct;
if (timeout == BIOS_NO_WAIT) {
return;
}
Assert_isTrue((timeout != BIOS_WAIT_FOREVER), Task_A_badTimeout);
/* add Clock event if timeout is not FOREVER */
if (BIOS_clockEnabled) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Task_sleepTimeout, timeout, &clockParams);
elem.clock = Clock_handle(&clockStruct);
}
hwiKey = Hwi_disable();
/* lock scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.task = Task_self();
Task_blockI(elem.task);
if (BIOS_clockEnabled) {
Clock_startI(elem.clock);
}
/* Only needed for Task_delete() */
Queue_elemClear(&elem.qElem);
elem.task->pendElem = (Ptr)(&elem);
Hwi_restore(hwiKey);
Log_write3(Task_LM_sleep, (UArg)elem.task, (UArg)elem.task->fxn,
(UArg)timeout);
Task_restore(tskKey); /* the calling task will block here */
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled) {
Clock_destruct(Clock_struct(elem.clock));
}
}
/*
* ======== TransportShm_openByAddr ========
*/
Int TransportShm_openByAddr(Ptr sharedAddr,
TransportShm_Handle *handlePtr,
Error_Block *eb)
{
TransportShm_Params params;
TransportShm_Attrs *attrs;
Int status;
UInt16 id;
if (sharedAddr == NULL) {
return (MessageQ_E_FAIL);
}
TransportShm_Params_init(¶ms);
/* Tell Instance_init() that we're opening */
params.openFlag = TRUE;
attrs = (TransportShm_Attrs *)sharedAddr;
id = SharedRegion_getId(sharedAddr);
/* Assert that the region is valid */
Assert_isTrue(id != SharedRegion_INVALIDREGIONID,
ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
/* invalidate the attrs before using it */
if (SharedRegion_isCacheEnabled(id)) {
Cache_inv(attrs, sizeof(TransportShm_Attrs), Cache_Type_ALL, TRUE);
}
/* set params field */
params.sharedAddr = sharedAddr;
params.priority = attrs->priority;
if (attrs->flag != TransportShm_UP) {
/* make sure transport is up */
*handlePtr = NULL;
status = MessageQ_E_NOTFOUND;
}
else {
/* Create the object */
*handlePtr = TransportShm_create(attrs->creatorProcId, ¶ms, eb);
if (*handlePtr == NULL) {
status = MessageQ_E_FAIL;
}
else {
status = MessageQ_S_SUCCESS;
}
}
return (status);
}
/*
* ======== Ipc_readConfig ========
*/
Int Ipc_readConfig(UInt16 remoteProcId, UInt32 tag, Ptr cfg, SizeT size)
{
Int status = Ipc_E_FAIL;
UInt16 clusterId = ti_sdo_utils_MultiProc_getClusterId(remoteProcId);
volatile ti_sdo_ipc_Ipc_ConfigEntry *entry;
Bool cacheEnabled = SharedRegion_isCacheEnabled(0);
/* Assert that the remoteProc in our cluster and isn't our own */
Assert_isTrue(clusterId < ti_sdo_utils_MultiProc_numProcsInCluster,
ti_sdo_utils_MultiProc_A_invalidMultiProcId);
if (cacheEnabled) {
Cache_inv(Ipc_module->procEntry[clusterId].remoteConfigList,
SharedRegion_getCacheLineSize(0),
Cache_Type_ALL,
TRUE);
}
entry = (ti_sdo_ipc_Ipc_ConfigEntry *)
*Ipc_module->procEntry[clusterId].remoteConfigList;
while ((SharedRegion_SRPtr)entry != ti_sdo_ipc_SharedRegion_INVALIDSRPTR) {
entry = (ti_sdo_ipc_Ipc_ConfigEntry *)
SharedRegion_getPtr((SharedRegion_SRPtr)entry);
/* Traverse the list to find the tag */
if (cacheEnabled) {
Cache_inv((Ptr)entry,
size + sizeof(ti_sdo_ipc_Ipc_ConfigEntry),
Cache_Type_ALL,
TRUE);
}
if ((entry->remoteProcId == MultiProc_self()) &&
(entry->localProcId == remoteProcId) &&
(entry->tag == tag)) {
if (size == entry->size) {
memcpy(cfg, (Ptr)((UInt32)entry + sizeof(ti_sdo_ipc_Ipc_ConfigEntry)),
entry->size);
return (Ipc_S_SUCCESS);
}
else {
return (Ipc_E_FAIL);
}
}
entry = (ti_sdo_ipc_Ipc_ConfigEntry *)entry->next;
}
return (status);
}
/*
* ======== Pd_init ========
*/
Void Pd_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);
}
/*!
* ======== InterruptDsp_intRegister ========
* Register ISR for remote processor interrupt
*/
Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
Fxn func, UArg arg)
{
Hwi_Params hwiAttrs;
UInt key;
Assert_isTrue(intInfo->intVectorId <= 15,
ti_sdo_ipc_Ipc_A_internal);
Assert_isTrue(intInfo->localIntId >= DSP_INT0 &&
intInfo->localIntId <= DSP_INT3,
ti_sdo_ipc_Ipc_A_internal);
Assert_isTrue(intInfo->remoteIntId == ARM_INT0 ||
intInfo->remoteIntId == ARM_INT1,
ti_sdo_ipc_Ipc_A_internal);
/* Disable global interrupts */
key = Hwi_disable();
InterruptDsp_intClear(remoteProcId, intInfo);
/* Register interrupt for communication between ARM and DSP */
Hwi_Params_init(&hwiAttrs);
hwiAttrs.maskSetting = Hwi_MaskingOption_SELF;
hwiAttrs.arg = arg;
hwiAttrs.eventId = intInfo->localIntId;
Hwi_create(intInfo->intVectorId,
(Hwi_FuncPtr)func,
&hwiAttrs,
NULL);
/* Restore global interrupts */
Hwi_restore(key);
/* enable the interrupt vector */
Hwi_enableInterrupt(intInfo->intVectorId);
}
/*!
* ======== InterruptDsp_intEnable ========
* Enable remote processor interrupt
*/
Void InterruptDsp_intEnable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo)
{
if (remoteProcId == InterruptDsp_hostProcId) {
REG32(MAILBOX_IRQENABLE_SET_DSP) = 0x40;
}
else if (remoteProcId == InterruptDsp_core0ProcId) {
REG32(MAILBOX_IRQENABLE_SET_DSP) = 0x10;
}
else {
/* DSP cannot talk to CORE1 */
Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);
}
}
/*
* ======== processWait ========
*/
static XDAS_Int32 processWait(IAUDENC1_Handle h, XDM1_BufDesc *inBufs,
XDM1_BufDesc *outBufs, IAUDENC1_InArgs *inArgs, IAUDENC1_OutArgs *outArgs,
UInt timeout)
{
XDAS_Int32 retVal;
_AUDENC1_Msg *msg;
VISA_Handle visa = (VISA_Handle)h;
Assert_isTrue(!VISA_isLocal(visa), (Assert_Id)NULL);
/* wait for completion of "last" message */
retVal = VISA_wait(visa, (VISA_Msg *)&msg, timeout);
/* Unmarshall outArgs if there is a msg to unmarshall. */
if (msg != NULL) {
Assert_isTrue(msg->visa.cmd == _AUDENC1_CPROCESS, (Assert_Id)NULL);
unmarshallMsg(h, inBufs, outBufs, inArgs, outArgs, msg);
}
return (retVal);
}
/*
* ======== TimestampProvider_Module_startup ========
*/
Int TimestampProvider_Module_startup( Int phase )
{
Clock_TimerProxy_Handle clockTimer;
if (BIOS_clockEnabled && TimestampProvider_useClockTimer) {
/* get Clock's timer handle */
clockTimer = Clock_getTimerHandle();
Assert_isTrue((clockTimer != NULL), NULL);
MOD->timer = (Timer_Handle)clockTimer;
}
return Startup_DONE;
}
/*
* ======== Mmu_initDescAttrs ========
*/
Void Mmu_initDescAttrs(Mmu_FirstLevelDescAttrs *attrs)
{
/* Assert that attrs != NULL */
Assert_isTrue(attrs != NULL, Mmu_A_nullPointer);
attrs->type = Mmu_defaultAttrs.type;
attrs->bufferable = Mmu_defaultAttrs.bufferable;
attrs->cacheable = Mmu_defaultAttrs.cacheable;
attrs->imp = Mmu_defaultAttrs.imp;
attrs->domain = Mmu_defaultAttrs.domain;
attrs->accPerm = Mmu_defaultAttrs.accPerm;
attrs->imp = Mmu_defaultAttrs.imp;
}
/*!
* ======== IntXbar_disconnectIRQ ========
*/
Void IntXbar_disconnectIRQ(UInt cpuIRQNum)
{
#ifdef xdc_target__isaCompatible_arp32
Assert_isTrue((cpuIRQNum <= 7),
IntXbar_A_badEveIRQNum);
IntXbar_disconnect(cpuIRQNum + 1);
#elif defined xdc_target__isaCompatible_66
Assert_isTrue((cpuIRQNum >= 32) && (cpuIRQNum <= 95),
IntXbar_A_badDspIRQNum);
IntXbar_disconnect(cpuIRQNum - 31);
#elif (defined xdc_target__isaCompatible_v7M4)
Assert_isTrue((cpuIRQNum >= 23) && (cpuIRQNum <= 79),
IntXbar_A_badBenelliIRQNum);
IntXbar_disconnect(cpuIRQNum - 22);
#elif defined xdc_target__isaCompatible_v7A15
Assert_isTrue((cpuIRQNum == 4) ||
((cpuIRQNum >= 7) && (cpuIRQNum <= 130)) ||
((cpuIRQNum >= 133) && (cpuIRQNum <= 138)) ||
((cpuIRQNum >= 141) && (cpuIRQNum <= 159)),
IntXbar_A_badA15IRQNum);
if (cpuIRQNum == 4) {
IntXbar_disconnect(cpuIRQNum - 3);
}
else if ((cpuIRQNum >= 7) && (cpuIRQNum <= 130)) {
IntXbar_disconnect(cpuIRQNum - 5);
}
else if ((cpuIRQNum >= 133) && (cpuIRQNum <= 138)) {
IntXbar_disconnect(cpuIRQNum - 7);
}
else if ((cpuIRQNum >= 141) && (cpuIRQNum <= 159)) {
IntXbar_disconnect(cpuIRQNum - 7);
}
#endif
}
/*
* ======== MessageQ_open ========
*/
Int MessageQ_open(String name, MessageQ_QueueId *queueId)
{
Int status;
Error_Block eb;
Assert_isTrue(name != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);
Assert_isTrue(queueId != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);
Error_init(&eb);
/* Search NameServer */
status = NameServer_getUInt32(
(NameServer_Handle)MessageQ_module->nameServer, name, queueId,
NULL);
if (status >= 0) {
return (MessageQ_S_SUCCESS); /* name found */
}
else {
return (MessageQ_E_NOTFOUND); /* name not found */
}
}
