/*---------------------------------------------------------------------------*
* Routine: sys_sem_new
*---------------------------------------------------------------------------*
* Description:
* Creates and returns a new semaphore. The "ucCount" argument specifies
* the initial state of the semaphore.
* NOTE: Currently this routine only creates counts of 1 or 0
* Inputs:
* sys_sem_t sem -- Handle of semaphore
* u8_t count -- Initial count of semaphore
* Outputs:
* err_t -- ERR_OK if semaphore created
*---------------------------------------------------------------------------*/
err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
ER ercd;
T_CSEM csem;
#ifdef CMSIS_OS_RTX
memset(sem->data, 0, sizeof(uint32_t)*2);
sem->def.semaphore = sem->data;
#endif
// sem->id = osSemaphoreCreate(&sem->def, count);
csem.sematr = NULL;
csem.isemcnt = count;
csem.maxsem = 1;
ercd = acre_sem(&csem);
// if (sem->id == NULL)
if (ercd < 0) {
// error("sys_sem_new create error\n");
syslog(LOG_EMERG, "sys_sem_new create error with code=%d\n", ercd);
return ERR_MEM;
}
sem->id = ercd;
syslog(LOG_DEBUG, "A new semaphore (ID=%d) was created.", sem->id);
return ERR_OK;
}
void sys_init(void) {
T_CSEM csem;
us_ticker_read(); // Init sys tick
// lwip_sys_mutex = osMutexCreate(osMutex(lwip_sys_mutex));
// create a semaphore because lwip_sys_mutex is used for mutual exclusion
csem.sematr = NULL;
csem.isemcnt = 1;
csem.maxsem = 1;
lwip_sys_mutex = acre_sem(&csem);
// if (lwip_sys_mutex == NULL)
if (lwip_sys_mutex < 0) {
error("sys_init error\n");
}
}
int InitMutex(wolfSSL_Mutex* m)
{
int iReturn;
m->sem.sematr = TA_TFIFO ;
m->sem.isemcnt = 1 ;
m->sem.maxsem = 1 ;
m->sem.name = NULL ;
m->id = acre_sem(&m->sem);
if( m->id != E_OK )
iReturn = 0;
else
iReturn = BAD_MUTEX_E;
return iReturn;
}
CgMutex *cg_mutex_new()
{
CgMutex *mutex;
cg_log_debug_l4("Entering...\n");
mutex = (CgMutex *)malloc(sizeof(CgMutex));
if ( NULL != mutex )
{
#if defined(WIN32) && !defined(ITRON)
mutex->mutexID = CreateMutex(NULL, FALSE, NULL);
#elif defined(BTRON)
mutex->mutexID = cre_sem(1, SEM_EXCL);
#elif defined(ITRON)
T_CSEM csem;
csem.sematr = TA_TFIFO;
csem.isemcnt = 1;
csem.maxsem = 1;
csem.name = NULL;
mutex->mutexID = acre_sem(&csem);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
T_CSEM csem;
csem.exinf = 0;
csem.sematr = TA_TFIFO | TA_FIRST;
csem.isemcnt = 0;
csem.maxsem = 1;
mutex->mutexID = tk_cre_sem(&csem);
#elif defined(TENGINE) && defined(PROCESS_BASE)
mutex->mutexID = b_cre_sem(1, SEM_EXCL);
#else
pthread_mutex_init(&mutex->mutexID, NULL);
#endif
}
cg_log_debug_l4("Leaving...\n");
return mutex;
}
static ER
handle_module_cfg_tab(T_LDM_CAN *ldm_can) {
// TODO: check cfg table memory
assert(ldm_can->cfg_entry_num > 0 && ldm_can->cfg_table != NULL);
assert(probe_ldm_memory(ldm_can->cfg_table, sizeof(MOD_CFG_ENTRY) * ldm_can->cfg_entry_num, ldm_can));
ER_ID ercd = E_OK;
// Creation stage
for(SIZE i = 0; i < ldm_can->cfg_entry_num && ercd == E_OK; ++i) {
MOD_CFG_ENTRY *ent = &ldm_can->cfg_table[i];
switch(ent->sfncd) {
case TSFN_CRE_TSK: {
syslog(LOG_DEBUG, "%s(): MOD_CFG_ENTRY TSFN_CRE_TSK", __FUNCTION__);
assert(probe_ldm_memory(ent->argument, sizeof(T_CTSK), ldm_can));
assert(probe_ldm_memory(ent->retvalptr, sizeof(ID), ldm_can));
T_CTSK pk_ctsk = *(T_CTSK*)ent->argument;
assert(probe_ldm_memory(pk_ctsk.stk, pk_ctsk.stksz, ldm_can)); // Check user stack
assert(pk_ctsk.sstk == NULL); // Check system stack
pk_ctsk.tskatr &= ~TA_ACT; // Clear TA_ACT
assert(get_atrdomid(pk_ctsk.tskatr) == TDOM_SELF); // Check original DOMID
pk_ctsk.tskatr |= TA_DOM(ldm_can->domid); // Set new DOMID
pk_ctsk.task = app_tsk_wrapper; // Use task wrapper
pk_ctsk.exinf = (intptr_t)ent->argument;
ercd = acre_tsk(&pk_ctsk);
assert(ercd > 0);
if(ercd > 0) {
// Store ID
*(ID*)ent->retvalptr = ercd;
// Setup task exception routine
T_DTEX dtex;
dtex.texatr = TA_NULL;
dtex.texrtn = app_tex_rtn;
ercd = def_tex(ercd, &dtex);
assert(ercd == E_OK);
#if defined(DEBUG)
syslog(LOG_NOTICE, "%s(): Task (tid = %d) created.", __FUNCTION__, *(ID*)ent->retvalptr);
#endif
ercd = E_OK;
}
break; }
case TSFN_CRE_SEM: {
syslog(LOG_DEBUG, "%s(): MOD_CFG_ENTRY TSFN_CRE_SEM", __FUNCTION__);
assert(probe_ldm_memory(ent->argument, sizeof(T_CSEM), ldm_can));
assert(probe_ldm_memory(ent->retvalptr, sizeof(ID), ldm_can));
T_CSEM pk_csem = *(T_CSEM*)ent->argument;
// TODO: check pk_csem
ercd = acre_sem(&pk_csem);
assert(ercd > 0);
if(ercd > 0) {
// Store ID
*(ID*)ent->retvalptr = ercd;
#if defined(DEBUG)
syslog(LOG_NOTICE, "%s(): Semaphore (id = %d) is created.", __FUNCTION__, *(ID*)ent->retvalptr);
#endif
ercd = E_OK;
}
break; }
case TSFN_CRE_FLG: {
syslog(LOG_DEBUG, "%s(): MOD_CFG_ENTRY TSFN_CRE_FLG", __FUNCTION__);
assert(probe_ldm_memory(ent->argument, sizeof(T_CFLG), ldm_can));
assert(probe_ldm_memory(ent->retvalptr, sizeof(ID), ldm_can));
T_CFLG pk_cflg = *(T_CFLG*)ent->argument;
// TODO: check pk_csem
ercd = acre_flg(&pk_cflg);
assert(ercd > 0);
if(ercd > 0) {
// Store ID
*(ID*)ent->retvalptr = ercd;
#if defined(DEBUG)
syslog(LOG_NOTICE, "%s(): Event flag (id = %d) is created.", __FUNCTION__, *(ID*)ent->retvalptr);
#endif
ercd = E_OK;
}
break; }
default:
syslog(LOG_ERROR, "%s(): Unsupported static function code %d.", __FUNCTION__, ent->sfncd);
ercd = E_OBJ;
}
}
// Rollback stage
// TODO: implement this
assert(ercd == E_OK);
syslog(LOG_DEBUG, "%s(): text paddr: 0x%x, data paddr: 0x%x", __FUNCTION__, ldm_can->text_mempool, ldm_can->data_mempool);
// Acting stage
for(SIZE i = 0; i < ldm_can->cfg_entry_num; ++i) {
MOD_CFG_ENTRY *ent = &ldm_can->cfg_table[i];
switch(ent->sfncd) {
case TSFN_CRE_TSK: {
T_CTSK pk_ctsk = *(T_CTSK*)ent->argument;
if(pk_ctsk.tskatr & TA_ACT) {
ercd = act_tsk(*(ID*)ent->retvalptr);
assert(ercd == E_OK);
}
break; }
default:
syslog(LOG_ERROR, "%s(): Unsupported static function code %d.", __FUNCTION__, ent->sfncd);
}
}
return ercd;
}
