bool mupnp_mutex_lock(mUpnpMutex *mutex)
{
if (!mutex)
return false;
mupnp_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
WaitForSingleObject(mutex->mutexID, INFINITE);
#elif defined(BTRON)
wai_sem(mutex->mutexID, T_FOREVER);
#elif defined(ITRON)
twai_sem(mutex->mutexID, TMO_FEVR);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_wai_sem(mutex->mutexID, 1, TMO_FEVR);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_wai_sem(mutex->mutexID, T_FOREVER);
#else
pthread_mutex_lock(&mutex->mutexID);
#endif
mupnp_log_debug_l4("Leaving...\n");
return true;
}
BOOL cg_mutex_lock(CgMutex *mutex)
{
if (!mutex)
return FALSE;
cg_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
WaitForSingleObject(mutex->mutexID, INFINITE);
#elif defined(BTRON)
wai_sem(mutex->mutexID, T_FOREVER);
#elif defined(ITRON)
twai_sem(mutex->mutexID, TMO_FEVR);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_wai_sem(mutex->mutexID, 1, TMO_FEVR);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_wai_sem(mutex->mutexID, T_FOREVER);
#else
pthread_mutex_lock(&mutex->mutexID);
#endif
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
void
task2(intptr_t exinf)
{
ER_UINT ercd;
switch (++task2_count) {
case 1:
check_point(2);
ercd = slp_tsk();
check_ercd(ercd, E_NOSPT);
ercd = tslp_tsk(TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = dly_tsk(TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_NOSPT);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_OK);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_TMOUT);
ercd = twai_sem(SEM1, TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
case 2:
check_point(6);
ercd = rot_rdq(MID_PRIORITY);
check_ercd(ercd, E_NOSPT);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
case 3:
check_point(10);
ercd = rot_rdq(MID_PRIORITY);
check_ercd(ercd, E_OK);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
default:
check_point(0);
}
check_point(0);
}
/*---------------------------------------------------------------------------*
* Routine: sys_arch_sem_wait
*---------------------------------------------------------------------------*
* Description:
* Blocks the thread while waiting for the semaphore to be
* signaled. If the "timeout" argument is non-zero, the thread should
* only be blocked for the specified time (measured in
* milliseconds).
*
* If the timeout argument is non-zero, the return value is the number of
* milliseconds spent waiting for the semaphore to be signaled. If the
* semaphore wasn't signaled within the specified time, the return value is
* SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
* (i.e., it was already signaled), the function may return zero.
*
* Notice that lwIP implements a function with a similar name,
* sys_sem_wait(), that uses the sys_arch_sem_wait() function.
* Inputs:
* sys_sem_t sem -- Semaphore to wait on
* u32_t timeout -- Number of milliseconds until timeout
* Outputs:
* u32_t -- Time elapsed or SYS_ARCH_TIMEOUT.
*---------------------------------------------------------------------------*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
u32_t start = us_ticker_read();
if (timeout != 0) {
if (twai_sem(sem->id, timeout) == E_TMOUT) {
// if (osSemaphoreWait(sem->id, (timeout != 0)?(timeout):(osWaitForever)) < 1)
return SYS_ARCH_TIMEOUT;
}
} else {
wai_sem(sem->id);
}
return (us_ticker_read() - start) / 1000;
}
/**
* @fn static int exec_by_interrupt(const SpiDeviceConfigurator_t* config, const void* pTx, int nTx, void* pRx, int nRx )
* @brief SPI execute using interrupt
* @param config a SPI Configuration
* @param pTx Tx Buffer pointer
* @param nTx number of the send units
* @param pRx Rx Buffer pointer
* @param nRx number of the receive units
*/
static int exec_by_interrupt(const SpiDeviceConfigurator_t* config, const void* pTx, int nTx, void* pRx, int nRx )
{
int ret = (nTx > nRx)? nTx : nRx;
spi_start(config,pTx,nTx,pRx,nRx);
ena_int(INHNO_SPI0);
if( twai_sem( SPI_COMPLETE_SIG , SPI_TIMEOUT_PER_BYTE * ret) != E_OK )
{
sig_sem( SPI_COMPLETE_SIG );
ret = 0;
}
return ret;
}
static int __ui_twai_sem(struct pt_regs *regs)
{
ID semid = __xn_reg_arg1(regs);
TMO tmout = __xn_reg_arg2(regs);
ER err;
err = twai_sem(semid, tmout);
if (err == E_RLWAI) {
uitask_t *task = ui_current_task();
if (!xnthread_test_info(&task->threadbase, uITRON_TASK_RLWAIT))
err = -EINTR;
}
return err;
}
/*
* メインタスク
*/
void main_task(intptr_t exinf)
{
char c;
ID tskid = TASK1;
int_t tskno = 1;
ER_UINT ercd;
PRI tskpri;
#ifndef TASK_LOOP
volatile ulong_t i;
SYSTIM stime1, stime2;
#endif /* TASK_LOOP */
#ifdef TOPPERS_SUPPORT_GET_UTM
SYSUTM utime1, utime2;
#endif /* TOPPERS_SUPPORT_GET_UTM */
T_CTSK ctsk;
T_DTEX dtex;
ID TASK3 = -1;
SVC_PERROR(syslog_msk_log(LOG_UPTO(LOG_INFO), LOG_UPTO(LOG_EMERG)));
syslog(LOG_NOTICE, "Sample program starts (exinf = %d).", (int_t) exinf);
/*
* シリアルポートの初期化
*
* システムログタスクと同じシリアルポートを使う場合など，シリアル
* ポートがオープン済みの場合にはここでE_OBJエラーになるが，支障は
* ない．
*/
ercd = serial_opn_por(TASK_PORTID);
if (ercd < 0 && MERCD(ercd) != E_OBJ) {
syslog(LOG_ERROR, "%s (%d) reported by `serial_opn_por'.",
itron_strerror(ercd), SERCD(ercd));
}
SVC_PERROR(serial_ctl_por(TASK_PORTID,
(IOCTL_CRLF | IOCTL_FCSND | IOCTL_FCRCV)));
/*
* ループ回数の設定
*
* 並行実行されるタスク内での空ループの回数（task_loop）は，空ルー
* プの実行時間が約0.4秒になるように設定する．この設定のために，
* LOOP_REF回の空ループの実行時間を，その前後でget_timを呼ぶことで
* 測定し，その測定結果から空ループの実行時間が0.4秒になるループ回
* 数を求め，task_loopに設定する．
*
* LOOP_REFは，デフォルトでは1,000,000に設定しているが，想定したよ
* り遅いプロセッサでは，サンプルプログラムの実行開始に時間がかか
* りすぎるという問題を生じる．逆に想定したより速いプロセッサでは，
* LOOP_REF回の空ループの実行時間が短くなり，task_loopに設定する値
* の誤差が大きくなるという問題がある．
*
* そこで，そのようなターゲットでは，target_test.hで，LOOP_REFを適
* 切な値に定義するのが望ましい．
*
* また，task_loopの値を固定したい場合には，その値をTASK_LOOPにマ
* クロ定義する．TASK_LOOPがマクロ定義されている場合，上記の測定を
* 行わずに，TASK_LOOPに定義された値を空ループの回数とする．
*
* ターゲットによっては，空ループの実行時間の1回目の測定で，本来よ
* りも長めになるものがある．このようなターゲットでは，MEASURE_TWICE
* をマクロ定義することで，1回目の測定結果を捨てて，2回目の測定結果
* を使う．
*
* タスク例外処理ルーチン内での空ループの回数（tex_loop）は，
* task_loopの4分の1の値（空ループの実行時間が0.1秒になるループ回
* 数）に設定する．
*/
#ifdef TASK_LOOP
task_loop = TASK_LOOP;
#else /* TASK_LOOP */
#ifdef MEASURE_TWICE
task_loop = LOOP_REF;
SVC_PERROR(get_tim(&stime1));
for (i = 0; i < task_loop; i++);
SVC_PERROR(get_tim(&stime2));
#endif /* MEASURE_TWICE */
task_loop = LOOP_REF;
SVC_PERROR(get_tim(&stime1));
for (i = 0; i < task_loop; i++);
SVC_PERROR(get_tim(&stime2));
task_loop = LOOP_REF * 400UL / (stime2 - stime1);
#endif /* TASK_LOOP */
tex_loop = task_loop / 4;
/*
* タスクの起動
*/
SVC_PERROR(act_tsk(TASK1));
SVC_PERROR(act_tsk(TASK2));
/*
* メインループ
*/
do {
SVC_PERROR(serial_rea_dat(TASK_PORTID, &c, 1));
switch (c) {
case 'e':
case 's':
case 'S':
case 'd':
case 'y':
case 'Y':
case 'z':
case 'Z':
message[tskno-1] = c;
break;
case '1':
tskno = 1;
tskid = TASK1;
break;
case '2':
tskno = 2;
tskid = TASK2;
break;
case '3':
tskno = 3;
tskid = TASK3;
break;
case 'a':
syslog(LOG_INFO, "#act_tsk(%d)", tskno);
SVC_PERROR(act_tsk(tskid));
break;
case 'A':
syslog(LOG_INFO, "#can_act(%d)", tskno);
SVC_PERROR(ercd = can_act(tskid));
if (ercd >= 0) {
syslog(LOG_NOTICE, "can_act(%d) returns %d", tskno, ercd);
}
break;
case 't':
syslog(LOG_INFO, "#ter_tsk(%d)", tskno);
SVC_PERROR(ter_tsk(tskid));
break;
case '>':
syslog(LOG_INFO, "#chg_pri(%d, HIGH_PRIORITY)", tskno);
SVC_PERROR(chg_pri(tskid, HIGH_PRIORITY));
break;
case '=':
syslog(LOG_INFO, "#chg_pri(%d, MID_PRIORITY)", tskno);
SVC_PERROR(chg_pri(tskid, MID_PRIORITY));
break;
case '<':
syslog(LOG_INFO, "#chg_pri(%d, LOW_PRIORITY)", tskno);
SVC_PERROR(chg_pri(tskid, LOW_PRIORITY));
break;
case 'G':
syslog(LOG_INFO, "#get_pri(%d, &tskpri)", tskno);
SVC_PERROR(ercd = get_pri(tskid, &tskpri));
if (ercd >= 0) {
syslog(LOG_NOTICE, "priority of task %d is %d", tskno, tskpri);
}
break;
case 'w':
syslog(LOG_INFO, "#wup_tsk(%d)", tskno);
SVC_PERROR(wup_tsk(tskid));
break;
case 'W':
syslog(LOG_INFO, "#can_wup(%d)", tskno);
SVC_PERROR(ercd = can_wup(tskid));
if (ercd >= 0) {
syslog(LOG_NOTICE, "can_wup(%d) returns %d", tskno, ercd);
}
break;
case 'l':
syslog(LOG_INFO, "#rel_wai(%d)", tskno);
SVC_PERROR(rel_wai(tskid));
break;
case 'u':
syslog(LOG_INFO, "#sus_tsk(%d)", tskno);
SVC_PERROR(sus_tsk(tskid));
break;
case 'm':
syslog(LOG_INFO, "#rsm_tsk(%d)", tskno);
SVC_PERROR(rsm_tsk(tskid));
break;
case 'x':
syslog(LOG_INFO, "#ras_tex(%d, 0x0001U)", tskno);
SVC_PERROR(ras_tex(tskid, 0x0001U));
break;
case 'X':
syslog(LOG_INFO, "#ras_tex(%d, 0x0002U)", tskno);
SVC_PERROR(ras_tex(tskid, 0x0002U));
break;
case 'r':
syslog(LOG_INFO, "#rot_rdq(three priorities)");
SVC_PERROR(rot_rdq(HIGH_PRIORITY));
SVC_PERROR(rot_rdq(MID_PRIORITY));
SVC_PERROR(rot_rdq(LOW_PRIORITY));
break;
case 'c':
syslog(LOG_INFO, "#sta_cyc(1)");
SVC_PERROR(sta_cyc(CYCHDR1));
break;
case 'C':
syslog(LOG_INFO, "#stp_cyc(1)");
SVC_PERROR(stp_cyc(CYCHDR1));
break;
case 'b':
syslog(LOG_INFO, "#sta_alm(1, 5000)");
SVC_PERROR(sta_alm(ALMHDR1, 5000));
break;
case 'B':
syslog(LOG_INFO, "#stp_alm(1)");
SVC_PERROR(stp_alm(ALMHDR1));
break;
case '@':
ctsk.tskatr = TA_NULL;
ctsk.exinf = 3;
ctsk.task = task;
ctsk.itskpri = MID_PRIORITY;
ctsk.stksz = STACK_SIZE;
ctsk.stk = NULL;
SVC_PERROR(TASK3 = acre_tsk(&ctsk));
dtex.texatr = TA_NULL;
dtex.texrtn = tex_routine;
SVC_PERROR(def_tex(TASK3, &dtex));
syslog(LOG_NOTICE, "task3 is created with tskid = %d.",
(int_t) TASK3);
break;
case '!':
syslog(LOG_INFO, "#del_tsk(%d)", tskno);
SVC_PERROR(del_tsk(tskid));
break;
case 'V':
#ifdef TOPPERS_SUPPORT_GET_UTM
SVC_PERROR(get_utm(&utime1));
SVC_PERROR(get_utm(&utime2));
syslog(LOG_NOTICE, "utime1 = %ld, utime2 = %ld",
(ulong_t) utime1, (ulong_t) utime2);
#else /* TOPPERS_SUPPORT_GET_UTM */
syslog(LOG_NOTICE, "get_utm is not supported.");
#endif /* TOPPERS_SUPPORT_GET_UTM */
break;
case 'v':
SVC_PERROR(syslog_msk_log(LOG_UPTO(LOG_INFO),
LOG_UPTO(LOG_EMERG)));
break;
case 'q':
SVC_PERROR(syslog_msk_log(LOG_UPTO(LOG_NOTICE),
LOG_UPTO(LOG_EMERG)));
break;
#ifdef BIT_KERNEL
case ' ':
SVC_PERROR(loc_cpu());
{
extern ER bit_kernel(void);
SVC_PERROR(ercd = bit_kernel());
if (ercd >= 0) {
syslog(LOG_NOTICE, "bit_kernel passed.");
}
}
SVC_PERROR(unl_cpu());
break;
#endif /* BIT_KERNEL */
case '$':
syslog(LOG_INFO, "#%d#twai_sem(10000)", tskno);
SVC_PERROR(twai_sem(TEST_SEM, 10000));
break;
default:
break;
}
} while (c != '\003' && c != 'Q');
syslog(LOG_NOTICE, "Sample program ends.");
SVC_PERROR(ext_ker());
assert(0);
}
void task1( unsigned int arg )
{
ER ercd;
int tests = 0;
CYG_TEST_INFO( "Task 1 running" );
ercd = dis_dsp();
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
ercd = sta_tsk( 2, 22222 );
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" );
ercd = chg_pri( 2, 5 );
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );
ercd = ena_dsp();
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_sem( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = del_sem( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = cre_sem( -6, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
ercd = cre_sem( 99, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
// check it is deleted
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" );
ercd = twai_sem( 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_sem( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
#endif
ercd = cre_sem( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
t_csem.sematr = 0xfff;
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" );
t_csem.sematr = 0;
#endif // we can test bad param error returns
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// and check we can use it
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" );
ercd = twai_sem( 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_sem( 1, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
ercd = cre_sem( 2, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete semaphores");
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_flg( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = del_flg( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = cre_flg( -6, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
ercd = cre_flg( 99, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
// check it is deleted
ercd = set_flg( 3, 0x6789 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 3, 0x9876 );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW );
CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" );
ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" );
ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_flg( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
#endif
ercd = cre_flg( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
t_cflg.flgatr = 0xfff;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" );
#endif // we can test bad param error returns
// now create it well
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = clr_flg( 3, 0x7256 );
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" );
ercd = set_flg( 3, 0xff );
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" );
ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now create it again with a preset pattern and check that we can
// detect that pattern:
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0x1234;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" );
ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 );
CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" );
ercd = clr_flg( 3, 0 );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaa, TWF_ANDW );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = set_flg( 1, 0x22 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 2, 0xdd );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
// re-create and do it again
t_cflg.iflgptn = 0x5555;
ercd = cre_flg( 1, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
t_cflg.iflgptn = 0;
ercd = cre_flg( 2, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = clr_flg( 1, 0xd00d );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = set_flg( 2, 0xfff00 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete flags");
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_mbx( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = del_mbx( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = cre_mbx( -6, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
ercd = cre_mbx( 99, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_mbx( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
// check it is deleted
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" );
ercd = trcv_msg( &msg, 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_mbx( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
#endif
ercd = cre_mbx( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
t_cmbx.mbxatr = 0xfff;
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" );
t_cmbx.mbxatr = 0;
#endif // we can test bad param error returns
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// and check we can use it
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" );
ercd = trcv_msg( &msg, 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_mbx( 1, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
ercd = cre_mbx( 2, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete mboxes");
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE
ercd = ter_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );
ercd = dly_tsk( 5 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
// all done
if ( 0 == tests ) {
CYG_TEST_NA( "No objects have create/delete enabled" );
}
else {
CYG_TEST_EXIT( "All done" );
}
ext_tsk();
}
void
task1(intptr_t exinf)
{
ER ercd;
check_point(1);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_CTX);
check_point(2);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_CTX);
ercd = twai_sem(SEM1, TMO_POL);
check_ercd(ercd, E_CTX);
ercd = unl_cpu();
check_ercd(ercd, E_OK);
check_point(3);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_OK);
ercd = twai_sem(SEM1, TMO_POL);
check_ercd(ercd, E_CTX);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
check_point(4);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_TMOUT);
ercd = twai_sem(SEM1, TMO_POL);
check_ercd(ercd, E_CTX);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
check_point(5);
ercd = twai_sem(SEM1, -2);
check_ercd(ercd, E_PAR);
ercd = twai_sem(SEM1, TMO_POL);
check_ercd(ercd, E_TMOUT);
check_point(6);
ercd = sta_alm(ALM1, 10);
check_ercd(ercd, E_OK);
check_point(7);
ercd = twai_sem(SEM1, TMO_FEVR);
check_ercd(ercd, E_OK);
check_point(11);
ercd = act_tsk(TASK3);
check_ercd(ercd, E_OK);
check_point(12);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_OK);
check_point(15);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_OK);
check_point(19);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_OK);
check_point(23);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(25);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_OK);
check_point(30);
ercd = sta_alm(ALM1, 10);
check_ercd(ercd, E_OK);
check_point(31);
ercd = twai_sem(SEM1, 100);
check_ercd(ercd, E_RLWAI);
check_point(33);
ercd = sta_alm(ALM1, 100);
check_ercd(ercd, E_OK);
check_point(34);
ercd = twai_sem(SEM1, 10);
check_ercd(ercd, E_TMOUT);
check_point(35);
ercd = stp_alm(ALM1);
check_ercd(ercd, E_OK);
check_finish(36);
check_point(0);
}
void
alarm1_handler(intptr_t exinf)
{
ER ercd;
switch (++alarm1_count) {
case 1:
check_point(8);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_CTX);
ercd = twai_sem(SEM1, TMO_POL);
check_ercd(ercd, E_CTX);
check_point(9);
ercd = iloc_cpu();
check_ercd(ercd, E_OK);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_CTX);
ercd = iunl_cpu();
check_ercd(ercd, E_OK);
check_point(10);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_OK);
return;
check_point(0);
case 2:
check_point(14);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_OK);
signal_var();
return;
check_point(0);
case 3:
check_point(17);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_OK);
signal_var();
return;
check_point(0);
case 4:
check_point(21);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_OK);
signal_var();
return;
check_point(0);
case 5:
check_point(28);
ercd = isig_sem(SEM1);
check_ercd(ercd, E_OK);
signal_var();
return;
check_point(0);
case 6:
check_point(32);
ercd = irel_wai(TASK1);
check_ercd(ercd, E_OK);
return;
check_point(0);
}
check_point(0);
}
void task1( unsigned int arg )
{
ER ercd;
int i;
T_RSYS rsys;
CYG_TEST_INFO( "Task 1 running" );
// check initial state
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" );
// disable intrs and check state
ercd = loc_cpu();
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// try an illegal op
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" );
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// enable intrs and check state and a legal sleep
ercd = unl_cpu();
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" );
ercd = dly_tsk( 1 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
// disable intrs and try scheduler illegal ops
ercd = loc_cpu();
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = dis_dsp();
CYG_TEST_CHECK( E_CTX == ercd, "dis_dsp bad ercd !E_CTX" );
ercd = ena_dsp();
CYG_TEST_CHECK( E_CTX == ercd, "ena_dsp bad ercd !E_CTX" );
#endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// enable again and check state
ercd = unl_cpu();
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" );
// disable the scheduler and check state
ercd = dis_dsp();
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_DDSP == rsys.sysstat, "system state not TSS_DDSP" );
// disable intrs and check state
ercd = loc_cpu();
CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" );
// then unlock and check state
ercd = unl_cpu();
CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" );
ercd = ref_sys( &rsys );
CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" );
CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" );
CYG_TEST_PASS( "Interrupt dis/enabling and interactions" );
// and now we can do the rest of the test
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = rel_wai( 2 );
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" );
ercd = rel_wai( 1 );
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" );
ercd = rel_wai( -6 );
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" );
ercd = rel_wai( 99 );
CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" );
#endif // we can test bad param error returns
ercd = dis_dsp();
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
ercd = sta_tsk( 2, 22222 );
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" );
ercd = chg_pri( 2, 5 );
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );
ercd = ena_dsp();
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = rel_wai( 2 );
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" );
ercd = rel_wai( 1 );
CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" );
#endif // we can test bad param error returns
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_sem bad ercd !E_RLWAI" );
ercd = twai_sem( 1, 20 );
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_sem bad ercd !E_RLWAI" );
ercd = wai_flg( &scratch, 1, 9999, 0 );
CYG_TEST_CHECK( E_RLWAI == ercd, "wai_flg bad ercd !E_RLWAI" );
ercd = twai_flg( &scratch, 1, 9999, 0, 10 );
CYG_TEST_CHECK( E_RLWAI == ercd, "twai_flg bad ercd !E_RLWAI" );
ercd = rcv_msg( &t_msg, 1 );
CYG_TEST_CHECK( E_RLWAI == ercd, "rcv_msg bad ercd !E_RLWAI" );
ercd = trcv_msg( &t_msg, 1, 10 );
CYG_TEST_CHECK( E_RLWAI == ercd, "trcv_msg bad ercd !E_RLWAI" );
// these are loops so as to consume the whole of the mempool
// in order to wait at the end
for ( i = 0; i < 10; i++ )
if ( E_OK != (ercd = get_blf( &vp, 3 ) ) )
break;
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blf bad ercd !E_RLWAI" );
for ( i = 0; i < 10; i++ )
if ( E_OK != (ercd = tget_blf( &vp, 3, 10 ) ) )
break;
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blf bad ercd !E_RLWAI" );
for ( i = 0; i < 10; i++ )
if ( E_OK != (ercd = get_blk( &vp, 1, 1000 ) ) )
break;
CYG_TEST_CHECK( E_RLWAI == ercd, "get_blk bad ercd !E_RLWAI" );
for ( i = 0; i < 10; i++ )
if ( E_OK != (ercd = tget_blk( &vp, 1, 1000, 10 ) ) )
break;
CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blk bad ercd !E_RLWAI" );
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_RLWAI == ercd, "dly_tsk bad ercd !E_RLWAI" );
ercd = tslp_tsk( 10 );
CYG_TEST_CHECK( E_RLWAI == ercd, "tslp_tsk bad ercd !E_RLWAI" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_RLWAI == ercd, "slp_tsk bad ercd !E_RLWAI" );
ercd = ter_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
CYG_TEST_PASS("release wait: various waiting calls");
// all done
CYG_TEST_EXIT( "All done" );
ext_tsk();
}
void take()
{
if (twai_sem(semid_, 500*5) == E_TMOUT)
throw timeout_error();
used_ = true;
}
void ITRON_Init( void )
{
ER status;
T_CSEM pk_csem;
T_RSEM pk_rsem;
printf( "\n\n*** ITRONSEM01 -- ITRON SEMAPHORE TEST ***\n" );
/*
* Exercise cre_sem - this code seems to exercise every path.
*/
puts( "Init - cre_sem - NULL pk_sem returns E_PAR" );
status = cre_sem( 1, NULL );
assert( status == E_PAR );
puts( "Init - cre_sem - isemcnt > maxsem returns E_PAR" );
pk_csem.sematr = 0;
pk_csem.isemcnt = 3;
pk_csem.maxsem = 2;
status = cre_sem( 1, &pk_csem );
assert( status == E_PAR );
puts( "Init - cre_sem - maxsem of 0 returns E_PAR" );
pk_csem.isemcnt = 0;
pk_csem.maxsem = 0;
status = cre_sem( 1, &pk_csem );
assert( status == E_PAR );
/*
* Now run through all the bad ID errors
*/
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
puts( "Init - cre_sem - bad id (less than -4) - E_OACV" );
status = cre_sem( -5, &pk_csem );
assert( status == E_OACV );
puts( "Init - cre_sem - bad id (between 0 and -4) - E_ID" );
status = cre_sem( -4, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - bad id (0) - E_ID" );
status = cre_sem( 0, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - bad id (too great) - E_ID" );
status = cre_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - create semaphore 1 TA_TFIFO - E_OK" );
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
pk_csem.sematr = TA_TFIFO;
status = cre_sem( 1, &pk_csem );
assert( status == E_OK );
puts( "Init - cre_sem - create semaphore 1 again - E_OBJ" );
status = cre_sem( 1, &pk_csem );
assert( status == E_OBJ );
puts( "Init - cre_sem - create semaphore 2 TA_TPRI - E_OK" );
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
pk_csem.sematr = TA_TPRI;
status = cre_sem( 2, &pk_csem );
assert( status == E_OK );
/*
* Generate all the bad id errors for del_sem
*/
puts( "Init - del_sem - bad id (less than -4) - E_OACV" );
status = del_sem( -5 );
assert( status == E_OACV );
puts( "Init - del_sem - bad id (between 0 and -4) - E_ID" );
status = del_sem( -4 );
assert( status == E_ID );
puts( "Init - del_sem - bad id (0) - E_ID" );
status = del_sem( 0 );
assert( status == E_ID );
puts( "Init - del_sem - bad id (too great) - E_ID" );
status = del_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for sig_sem
*/
puts( "Init - sig_sem - bad id (less than -4) - E_OACV" );
status = sig_sem( -5 );
assert( status == E_OACV );
puts( "Init - sig_sem - bad id (between 0 and -4) - E_ID" );
status = sig_sem( -4 );
assert( status == E_ID );
puts( "Init - sig_sem - bad id (0) - E_ID" );
status = sig_sem( 0 );
assert( status == E_ID );
puts( "Init - sig_sem - bad id (too great) - E_ID" );
status = wai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for preq_sem
*/
puts( "Init - preq_sem - bad id (less than -4) - E_OACV" );
status = preq_sem( -5 );
assert( status == E_OACV );
puts( "Init - preq_sem - bad id (between 0 and -4) - E_ID" );
status = preq_sem( -4 );
assert( status == E_ID );
puts( "Init - preq_sem - bad id (0) - E_ID" );
status = preq_sem( 0 );
assert( status == E_ID );
puts( "Init - preq_sem - bad id (too great) - E_ID" );
status = preq_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for wai_sem
*/
puts( "Init - wai_sem - bad id (less than -4) - E_OACV" );
status = wai_sem( -5 );
assert( status == E_OACV );
puts( "Init - wai_sem - bad id (between 0 and -4) - E_ID" );
status = wai_sem( -4 );
assert( status == E_ID );
puts( "Init - wai_sem - bad id (0) - E_ID" );
status = wai_sem( 0 );
assert( status == E_ID );
puts( "Init - wai_sem - bad id (too great) - E_ID" );
status = wai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for twai_sem
*/
puts( "Init - twai_sem - bad id (less than -4) - E_OACV" );
status = twai_sem( -5, 1000 );
assert( status == E_OACV );
puts( "Init - twai_sem - bad id (between 0 and -4) - E_ID" );
status = twai_sem( -4, 1000 );
assert( status == E_ID );
puts( "Init - twai_sem - bad id (0) - E_ID" );
status = twai_sem( 0, 1000 );
assert( status == E_ID );
puts( "Init - twai_sem - bad id (too great) - E_ID" );
status = twai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, 1000 );
assert( status == E_ID );
/*
* Generate all the bad id errors for ref_sem
*/
puts( "Init - ref_sem - bad id (less than -4) - E_OACV" );
status = ref_sem( -5, &pk_rsem );
assert( status == E_OACV );
puts( "Init - ref_sem - bad id (between 0 and -4) - E_ID" );
status = ref_sem( -4, &pk_rsem );
assert( status == E_ID );
puts( "Init - ref_sem - bad id (0) - E_ID" );
status = ref_sem( 0, &pk_rsem );
assert( status == E_ID );
puts( "Init - ref_sem - bad id (too great) - E_ID" );
status = ref_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, &pk_rsem );
assert( status == E_ID );
/*
* Exercise preq_sem (and sig_sem a little)
*/
puts( "Init - preq_sem - semaphore 1 available (count --> 1) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - preq_sem - semaphore 1 available (count --> 0) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - preq_sem - semaphore 1 unavailable - E_TMOUT" );
status = preq_sem( 1 );
assert( status == E_TMOUT );
puts( "Init - sig_sem - semaphore 1 (count --> 1) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts("Init - twai_sem(TMO_POL) - semaphore 1 available (count --> 0) - E_OK");
status = twai_sem( 1, TMO_POL );
assert( status == E_OK );
puts( "Init - twai_sem(TMO_POL) - semaphore 1 available - E_TMOUT" );
status = twai_sem( 1, TMO_POL );
assert( status == E_TMOUT );
/*
* Exercise twai_sem
*/
puts( "Init - twai_sem - semaphore 1 unavailable - 1 second E_TMOUT" );
put_time( "Init - starting to block at ");
status = twai_sem( 1, 1000 );
assert( status == E_TMOUT );
put_time( "Init - timed out at ");
puts( "Init - twai_sem - semaphore 1 unavailable - timeout completed" );
/*
* Now let's test exceed the maximum count of semaphore 1
*/
puts( "Init - sig_sem - semaphore 1 (count --> 1) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count --> 2) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count --> 3) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count > maximum) - E_QOVR" );
status = sig_sem( 1 );
assert( status == E_QOVR );
/*
* Exercise ref_sem
*/
puts( "Init - ref_sem - NULL pk_sem returns E_PAR" );
status = ref_sem( 1, NULL );
assert( status == E_PAR );
puts( "Init - ref_sem - semaphore 1 - E_OK" );
status = ref_sem( 1, &pk_rsem );
assert( status == E_OK );
printf( "Init - semaphore 1 count = %d\n", pk_rsem.semcnt );
printf( "Init - semaphore 1 waiting tasks = %d\n", pk_rsem.wtsk );
puts( "Init - preq_sem - semaphore 1 (count --> 2) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - ref_sem - semaphore 1 - E_OK" );
status = ref_sem( 1, &pk_rsem );
assert( status == E_OK );
printf( "Init - semaphore 1 count = %d\n", pk_rsem.semcnt );
printf( "Init - semaphore 1 waiting tasks = %d\n", pk_rsem.wtsk );
/*
* Exercise del_sem
*/
/* XXX really want another task blocking on the semaphore XXX */
puts( "Init - del_sem - semaphore 1 deleted - E_OK" );
status = del_sem( 1 );
assert( status == E_OK );
puts( "Init - XXX need other tasks to complete the test XXX" );
puts( "Init - dly_tsk - 1 second to let other task run" );
status = dly_tsk( 1000 );
assert( status == E_OK );
printf( "*** END OF ITRONSEM01 -- ITRON SEMAPHORE TEST ***\n" );
rtems_test_exit( 0 );
}
