/*
* ======== main ========
*/
Void main()
{
Swi_Params swiParams;
Task_Params taskParams;
Clock_Params clkParams;
Swi_Params_init(&swiParams);
swiParams.arg0 = 1;
swiParams.arg1 = 0;
swiParams.priority = 2;
swiParams.trigger = 0;
swi0 = Swi_create(swi0Fxn, &swiParams, NULL);
swiParams.arg0 = 2;
swiParams.arg1 = 0;
swiParams.priority = 1;
swiParams.trigger = 3;
swi1 = Swi_create(swi1Fxn, &swiParams, NULL);
Task_Params_init(&taskParams);
taskParams.priority = 1;
Task_create (tsk0Fxn, &taskParams, NULL);
Clock_Params_init(&clkParams);
clkParams.startFlag = TRUE;
Clock_create(clk0Fxn, 2, &clkParams, NULL);
sem0 = Semaphore_create(0, NULL, NULL);
BIOS_start();
}
void SWI::begin(void (*functionSWI)(void))
{
Error_Block eb;
Error_init(&eb);
Swi_Params swiParams;
Swi_Params_init(&swiParams);
SWIHandle = Swi_create((Swi_FuncPtr)functionSWI, &swiParams, &eb);
}
//void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)(uint8_t))
void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)())
{
Error_Block eb;
Error_init(&eb);
Swi_Params swiParams;
Swi_Params_init(&swiParams);
swiParams.trigger = trigger;
// SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger(Swi_getTrigger()), &swiParams, &eb);
SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger, &swiParams, &eb);
if (SWItriggerHandle == NULL)
{
System_abort("SWItrigger create failed");
}
}
/*
* ======== IpcPower_init ========
*/
Void IpcPower_init()
{
Swi_Params swiParams;
Task_Params taskParams;
Int i;
UArg arg;
UInt func;
Timer_Handle tHandle = NULL;
if (curInit++) {
return;
}
IpcPower_hibLock = 0;
for (i = 0; i < Timer_Object_count(); i++) {
tHandle = Timer_Object_get(NULL, i);
func = (UInt) Timer_getFunc(tHandle, &arg);
if (func && ((func == (UInt) ti_sysbios_knl_Clock_doTick__I) ||
(func == (UInt) Clock_tick) ||
(func == (UInt) IpcPower_clockFxn))) {
tickTimerHandle = tHandle;
break;
}
}
if (tickTimerHandle == NULL) {
System_abort("IpcPower_init: Cannot find tickTimer Handle. Custom"
" clock timer functions currently not supported.\n");
}
IpcPower_semSuspend = Semaphore_create(0, NULL, NULL);
IpcPower_semExit = Semaphore_create(0, NULL, NULL);
Task_Params_init(&taskParams);
taskParams.priority = Task_numPriorities - 1; /* Highest priority */
taskParams.instance->name = "ti.pm.IpcPower_tskSuspend";
IpcPower_tskSuspend = Task_create(IpcPower_suspendTaskFxn, &taskParams,
NULL);
Swi_Params_init(&swiParams);
swiParams.priority = Swi_numPriorities - 1; /* Max Priority Swi */
suspendResumeSwi = Swi_create(IpcPower_suspendSwi, &swiParams, NULL);
}
/*
* ======== Swi_setAttrs ========
*/
Void Swi_setAttrs(Swi_Object *swi, Swi_FuncPtr fxn, Swi_Params *params)
{
UInt hwiKey;
Swi_Params swiParams;
if (params == NULL) {
Swi_Params_init(&swiParams);
params = &swiParams;
}
hwiKey = Hwi_disable();
/* defensively remove swi from its readyQ */
Queue_remove((Queue_Elem *)swi);
if (fxn) {
swi->fxn = fxn;
}
swi->posted = FALSE;
swi->arg0 = params->arg0;
swi->arg1 = params->arg1;
if (params->priority == ~0) {
swi->priority = Swi_numPriorities - 1;
}
else {
swi->priority = params->priority;
}
Assert_isTrue((swi->priority < Swi_numPriorities),
Swi_A_badPriority);
swi->mask = 1 << swi->priority;
swi->initTrigger = swi->trigger = params->trigger;
swi->readyQ = Queue_Object_get(Swi_module->readyQ, swi->priority);
Hwi_restore(hwiKey);
}
/*
* ======== IpcPower_init ========
*/
Void IpcPower_init()
{
Swi_Params swiParams;
#ifndef SMP
Task_Params taskParams;
UInt coreIdx = Core_getId();
#endif
Int i;
UArg arg;
UInt func;
Timer_Handle tHandle = NULL;
if (curInit++) {
return;
}
#ifndef SMP
IpcPower_hibLocks[coreIdx] = 0;
sysm3ProcId = MultiProc_getId("CORE0");
appm3ProcId = MultiProc_getId("CORE1");
#else
IpcPower_hibLocks = 0;
#endif
refWakeLockCnt = 0;
for (i = 0; i < Timer_Object_count(); i++) {
tHandle = Timer_Object_get(NULL, i);
func = (UInt) Timer_getFunc(tHandle, &arg);
if (func && ((func == (UInt) ti_sysbios_knl_Clock_doTick__I) ||
(func == (UInt) Clock_tick) ||
(func == (UInt) IpcPower_clockFxn))) {
tickTimerHandle = tHandle;
break;
}
}
if (tickTimerHandle == NULL) {
System_abort("IpcPower_init: Cannot find tickTimer Handle. Custom"
" clock timer functions currently not supported.\n");
}
#ifndef SMP
IpcPower_semSuspend = Semaphore_create(0, NULL, NULL);
IpcPower_semExit = Semaphore_create(0, NULL, NULL);
Task_Params_init(&taskParams);
taskParams.priority = Task_numPriorities - 1; /* Highest priority */
taskParams.instance->name = "ti.pm.IpcPower_tskSuspend";
IpcPower_tskSuspend = Task_create(IpcPower_suspendTaskFxn, &taskParams,
NULL);
#endif
Swi_Params_init(&swiParams);
swiParams.priority = Swi_numPriorities - 1; /* Max Priority Swi */
suspendResumeSwi = Swi_create(IpcPower_suspendSwi, &swiParams, NULL);
/*Power settings for saving/restoring context */
PowerSuspArgs.rendezvousResume = TRUE;
PowerSuspArgs.dmaChannel = CPU_COPY;
PowerSuspArgs.intMask31_0 = 0x0;
#ifndef SMP
PowerSuspArgs.intMask63_32 = 0x0;
#else
PowerSuspArgs.intMask63_32 = WUGEN_MAILBOX_BIT << 16;
#endif
PowerSuspArgs.intMask79_64 = 0x0;
IpcPower_sleepMode(IpcPower_SLEEP_MODE_DEEPSLEEP);
IpcPower_setWugen();
}
/*
* ======== TransportShm_Instance_init ========
*/
Int TransportShm_Instance_init(TransportShm_Object *obj,
UInt16 procId, const TransportShm_Params *params,
Error_Block *eb)
{
Int localIndex;
Int remoteIndex;
Int status;
Bool flag;
UInt32 minAlign;
ListMP_Params listMPParams[2];
Swi_Handle swiHandle;
Swi_Params swiParams;
Ptr localAddr;
swiHandle = TransportShm_Instance_State_swiObj(obj);
/*
* Determine who gets the '0' slot in shared memory and who gets
* the '1' slot. The '0' slot is given to the lower MultiProc id.
*/
if (MultiProc_self() < procId) {
localIndex = 0;
remoteIndex = 1;
}
else {
localIndex = 1;
remoteIndex = 0;
}
if (params->openFlag) {
/* Open by sharedAddr */
obj->objType = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC;
obj->self = (TransportShm_Attrs *)params->sharedAddr;
obj->regionId = SharedRegion_getId(params->sharedAddr);
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
localAddr = SharedRegion_getPtr(obj->self->gateMPAddr);
status = GateMP_openByAddr(localAddr, (GateMP_Handle *)&obj->gate);
if (status < 0) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return(1);
}
}
else {
/* init the gate for ListMP create below */
if (params->gate != NULL) {
obj->gate = params->gate;
}
else {
obj->gate = (ti_sdo_ipc_GateMP_Handle)GateMP_getDefaultRemote();
}
/* Creating using sharedAddr */
obj->regionId = SharedRegion_getId(params->sharedAddr);
/* Assert that the buffer is in a valid shared region */
Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID,
ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
/* Assert that sharedAddr is cache aligned */
Assert_isTrue(((UInt32)params->sharedAddr %
SharedRegion_getCacheLineSize(obj->regionId) == 0),
ti_sdo_ipc_Ipc_A_addrNotCacheAligned);
/* set object's cacheEnabled, type, self */
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC;
obj->self = (TransportShm_Attrs *)params->sharedAddr;
}
/* determine the minimum alignment to align to */
minAlign = Memory_getMaxDefaultTypeAlign();
if (SharedRegion_getCacheLineSize(obj->regionId) > minAlign) {
minAlign = SharedRegion_getCacheLineSize(obj->regionId);
}
/*
* Carve up the shared memory.
* If cache is enabled, these need to be on separate cache lines.
* This is done with minAlign and _Ipc_roundup function.
*/
obj->other = (TransportShm_Attrs *)((UInt32)(obj->self) +
(_Ipc_roundup(sizeof(TransportShm_Attrs), minAlign)));
ListMP_Params_init(&(listMPParams[0]));
listMPParams[0].gate = (GateMP_Handle)obj->gate;
listMPParams[0].sharedAddr = (UInt32 *)((UInt32)(obj->other) +
(_Ipc_roundup(sizeof(TransportShm_Attrs), minAlign)));
ListMP_Params_init(&listMPParams[1]);
listMPParams[1].gate = (GateMP_Handle)obj->gate;
listMPParams[1].sharedAddr = (UInt32 *)((UInt32)(listMPParams[0].sharedAddr)
+ ListMP_sharedMemReq(&listMPParams[0]));
obj->priority = params->priority;
obj->remoteProcId = procId;
Swi_Params_init(&swiParams);
swiParams.arg0 = (UArg)obj;
Swi_construct(Swi_struct(swiHandle),
(Swi_FuncPtr)TransportShm_swiFxn,
&swiParams, eb);
if (params->openFlag == FALSE) {
obj->localList = (ti_sdo_ipc_ListMP_Handle)
ListMP_create(&(listMPParams[localIndex]));
if (obj->localList == NULL) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (2);
}
obj->remoteList = (ti_sdo_ipc_ListMP_Handle)
ListMP_create(&(listMPParams[remoteIndex]));
if (obj->localList == NULL) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (2);
}
}
else {
/* Open the local ListMP instance */
status = ListMP_openByAddr(listMPParams[localIndex].sharedAddr,
(ListMP_Handle *)&(obj->localList));
if (status < 0) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (2);
}
/* Open the remote ListMP instance */
status = ListMP_openByAddr(listMPParams[remoteIndex].sharedAddr,
(ListMP_Handle *)&(obj->remoteList));
if (status < 0) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (2);
}
}
/* register the event with Notify */
status = Notify_registerEventSingle(
procId, /* remoteProcId */
0, /* lineId */
TransportShm_notifyEventId,
(Notify_FnNotifyCbck)TransportShm_notifyFxn,
(UArg)swiHandle);
if (status < 0) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (3);
}
/* Register the transport with MessageQ */
flag = ti_sdo_ipc_MessageQ_registerTransport(
TransportShm_Handle_upCast(obj), procId, params->priority);
if (flag == FALSE) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (4);
}
if (params->openFlag == FALSE) {
obj->self->creatorProcId = MultiProc_self();
obj->self->notifyEventId = TransportShm_notifyEventId;
obj->self->priority = obj->priority;
/* Store the GateMP sharedAddr in the Attrs */
obj->self->gateMPAddr = ti_sdo_ipc_GateMP_getSharedAddr(obj->gate);
obj->self->flag = TransportShm_UP;
if (obj->cacheEnabled) {
Cache_wbInv(obj->self, sizeof(TransportShm_Attrs),
Cache_Type_ALL, TRUE);
}
}
else {
obj->other->flag = TransportShm_UP;
if (obj->cacheEnabled) {
Cache_wbInv(&(obj->other->flag), minAlign, Cache_Type_ALL, TRUE);
}
}
obj->status = TransportShm_UP;
return (0);
}
