DvevmStRetCode dvtb_audDec1SemOpen(SemThread_Handle *sem_in, int valIn, SemThread_Handle *sem_out, int valOut, SemThread_Handle *sem_block, int valBlock) { DvevmStRetCode retval = DVEVM_ST_SUCCESS; SemThread_Params semParams; SemThread_Params_init(&semParams); semParams.mode = SemThread_Mode_COUNTING; semParams.name = "Sem_In"; *sem_in = SemThread_create(valIn, &semParams); SemThread_Params_init(&semParams); semParams.mode = SemThread_Mode_COUNTING; semParams.name = "Sem_Out"; *sem_out = SemThread_create(valOut, &semParams); SemThread_Params_init(&semParams); semParams.mode = SemThread_Mode_BINARY; semParams.name = "Sem_Block"; *sem_block = SemThread_create(valBlock, &semParams); if ((NULL == *sem_in) || (NULL == *sem_out) || (NULL == *sem_block)) { SYS_ERROR("sem_open() FAILED\n"); retval = DVEVM_ST_FAIL; } return retval; }
/* ARGSUSED */ Void smain(UArg arg0, UArg arg1) { SemThread_Params semParams; Task_Params taskParams; Task_Handle tsk; Int i; Log_print0(Diags_ENTRY, "[+E] smain> Enter "); SemThread_Params_init(&semParams); done = SemThread_create(0, &semParams, NULL); SemThread_Params_init(&semParams); mutex = SemThread_create(1, &semParams, NULL); if ((done == NULL) || (mutex == NULL)) { Log_print0(Diags_USER7, "[+7] smain> SemThread creation failed"); System_abort("SemThread_create failed \n"); } Task_Params_init(&taskParams); /* * Add the following line to have the stack allocated from the external * heap: * taskParams.stackHeap = (IHeap_Handle)EXTMEM_HEAP; */ taskParams.stackSize = 0x1000; for (i = 0; i < NUMTASKS; i++) { Task_Params_init(&taskParams); taskParams.priority = attrsTable[i].priority; taskParams.arg0 = i + 1; /* task id */ taskParams.arg1 = i; /* index into attrsTable */ tsk = Task_create((Task_FuncPtr)rmanTask, &taskParams, NULL); if (tsk == NULL) { Log_print1(Diags_USER7, "[+7] smain> Task_create of task %d failed", (IArg)(i + 1)); System_abort("Task_create() failed\n"); } } for (i = 0; i < NUMTASKS; i++) { SemThread_pend(done, SemThread_FOREVER, NULL); } SemThread_delete(&mutex); SemThread_delete(&done); Log_print0(Diags_USER4, "[+4] smain> TEST PASSED "); Log_print0(Diags_EXIT, "[+X] smain> Exit "); }
/* ARGSUSED */ Int SyncSemThread_Instance_init(SyncSemThread_Object *obj, const SyncSemThread_Params *params, Error_Block *eb) { SemThread_Params semParams; /* initialize object data */ obj->semThread = NULL; /* create the semaphore */ SemThread_Params_init(&semParams); semParams.mode = SemThread_Mode_BINARY; obj->semThread = SemThread_create(0, &semParams, eb); return (0); }
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); }
Int RcmClient_Instance_init(RcmClient_Object *obj, String server, const RcmClient_Params *params) { Error_Block eb; MessageQ_Params mqParams; SyncSemThread_Params syncParams; SemThread_Params semParams; SemThread_Handle semHndl; List_Params listP; Int rval; Int status = RcmClient_S_SUCCESS; Log_print2(Diags_ENTRY, "--> %s: (obj=0x%x)", (IArg)FXNN, (IArg)obj); /* must initialize error block */ Error_init(&eb); /* initialize instance data */ obj->msgId = 0xFFFF; obj->sync = NULL; obj->serverMsgQ = MessageQ_INVALIDMESSAGEQ; obj->msgQue = NULL; obj->errorMsgQue = NULL; obj->mbxLock = NULL; obj->queueLock = NULL; obj->recipients = NULL; obj->newMail = NULL; /* create the instance gate */ GateThread_construct(&obj->gate, NULL, &eb); if (Error_check(&eb)) { Log_error0(FXNN": could not create gate object"); status = RcmClient_E_FAIL; goto leave; } /* create a synchronizer for the message queue */ SyncSemThread_Params_init(&syncParams); obj->sync = SyncSemThread_create(&syncParams, &eb); if (Error_check(&eb)) { status = RcmClient_E_FAIL; goto leave; } /* create the message queue for return messages */ MessageQ_Params_init(&mqParams); obj->msgQue = MessageQ_create(NULL, &mqParams); if (obj->msgQue == NULL) { Log_error0(FXNN": could not create return message queue"); status = RcmClient_E_MSGQCREATEFAILED; goto leave; } /* create the message queue for error messages */ MessageQ_Params_init(&mqParams); obj->errorMsgQue = MessageQ_create(NULL, &mqParams); if (NULL == obj->errorMsgQue) { Log_error0(FXNN": could not create error message queue"); status = RcmClient_E_MSGQCREATEFAILED; goto leave; } /* locate server message queue */ rval = MessageQ_open(server, (MessageQ_QueueId *)(&obj->serverMsgQ)); if (MessageQ_E_NOTFOUND == rval) { Log_error1(FXNN": given server not found, server=0x%x", (IArg)server); status = RcmClient_E_SERVERNOTFOUND; goto leave; } else if (status < 0) { Log_error1(FXNN": could not open server message queue, server=0x%x", (IArg)server); status = RcmClient_E_MSGQOPENFAILED; goto leave; } /* create callback server */ if ((obj->cbNotify = params->callbackNotification)) { /* TODO create callback server thread */ /* make sure to free resources acquired by thread */ Error_raise(&eb, Error_E_generic, "Not Implemented", 0); goto leave; } /* register the heapId used for message allocation */ if ((obj->heapId = params->heapId) == RcmClient_INVALIDHEAPID) { Log_error0(FXNN": must specify a heap id in create params"); status = RcmClient_E_INVALIDHEAPID; goto leave; } /* create the mailbox lock */ SemThread_Params_init(&semParams); semHndl = SemThread_create(1, &semParams, &eb); if (Error_check(&eb)) { status = RcmClient_E_FAIL; goto leave; } obj->mbxLock = SemThread_Handle_upCast(semHndl); /* create the message queue lock */ SemThread_Params_init(&semParams); semHndl = SemThread_create(1, &semParams, &eb); if (Error_check(&eb)) { status = RcmClient_E_FAIL; goto leave; } obj->queueLock = SemThread_Handle_upCast(semHndl); /* create the return message recipient list */ #if defined(RCM_ti_ipc) List_Params_init(&listP); obj->recipients = List_create(&listP, &eb); if (Error_check(&eb)) { Log_error0(FXNN": could not create list object"); status = RcmClient_E_LISTCREATEFAILED; goto leave; } #elif defined(RCM_ti_syslink) List_Params_init(&listP); obj->recipients = List_create(&listP, NULL); if (NULL == obj->recipients) { Log_error0(FXNN": could not create list object"); status = RcmClient_E_LISTCREATEFAILED; goto leave; } #endif /* create list of undelivered messages (new mail) */ #if defined(RCM_ti_ipc) List_Params_init(&listP); obj->newMail = List_create(&listP, &eb); if (Error_check(&eb)) { Log_error0(FXNN": could not create list object"); status = RcmClient_E_LISTCREATEFAILED; goto leave; } #elif defined(RCM_ti_syslink) List_Params_init(&listP); obj->newMail = List_create(&listP, NULL); if (NULL == obj->newMail) { Log_error0(FXNN": could not create list object"); status = RcmClient_E_LISTCREATEFAILED; goto leave; } #endif leave: Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status); return(status); }
/* * ======== Hello_start ======== * * 1. create semaphore object * 2. register notify callback * 3. wait until remote core has also registered notify callback * 4. create local & shared resources * 5. send resource ready event * 6. wait for remote resource ready event * 7. open remote resources * 8. handshake the ready event */ Int Hello_start(UInt16 remoteProcId) { Int status; UInt32 event; SemThread_Params semParams; HeapBufMP_Params heapParams; Error_Block eb; Error_init(&eb); Module.remoteProcId = remoteProcId; /* * 1. create semaphore object */ SemThread_Params_init(&semParams); semParams.mode = SemThread_Mode_COUNTING; SemThread_construct(&Module.semS, 0, &semParams, &eb); if (Error_check(&eb)) { status = -15; goto leave; } Module.semH = SemThread_handle(&Module.semS); /* * 2. register notify callback */ status = Notify_registerEventSingle(Module.remoteProcId, Module.lineId, Module.eventId, Hello_notifyCB, (UArg)&Module); if (status < 0) { goto leave; } /* * 3. wait until remote core has also registered notify callback */ do { status = Notify_sendEvent(Module.remoteProcId, Module.lineId, Module.eventId, App_CMD_NOP, TRUE); if (status == Notify_E_EVTNOTREGISTERED) { Thread_sleep(1000, &eb); /* microseconds */ } } while (status == Notify_E_EVTNOTREGISTERED); if (status < 0) { goto leave; } /* * 4. create local & shared resources (to be opened by remote processor) */ /* create heap for rcm messages */ HeapBufMP_Params_init(&heapParams); heapParams.name = Global_RcmClientHeapName; heapParams.regionId = 0; heapParams.blockSize = 0x200; /* 512 B */ heapParams.numBlocks = 8; Module.msgHeap = HeapBufMP_create(&heapParams); if (Module.msgHeap == NULL) { Log_error0("Hello_start: HeapBuf_create() failed"); status = -1; goto leave; } /* register heap with MessageQ */ status = MessageQ_registerHeap((Ptr)(Module.msgHeap), Global_RcmClientHeapId); if (status < 0) { goto leave; } /* * 5. send resource ready event */ status = Notify_sendEvent(Module.remoteProcId, Module.lineId, Module.eventId, App_CMD_RESRDY, TRUE); if (status < 0) { goto leave; } /* * 6. wait for remote resource ready event */ do { event = Hello_waitForEvent(); if (event >= App_E_FAILURE) { status = -1; goto leave; } } while (event != App_CMD_RESRDY); /* * 7. open remote resources */ /* * 8. handshake the ready event */ status = Notify_sendEvent(Module.remoteProcId, Module.lineId, Module.eventId, App_CMD_READY, TRUE); if (status < 0) { goto leave; } do { event = Hello_waitForEvent(); if (event >= App_E_FAILURE) { status = -1; goto leave; } } while (event != App_CMD_READY); leave: return(status); }