Ejemplo n.º 1
0
ER_UINT
can_act(ID tskid)
{
	TCB		*p_tcb;
	ER_UINT	ercd;

	LOG_CAN_ACT_ENTER(tskid);
	CHECK_TSKCTX_UNL();							/*[NGKI1139][NGKI1140]*/
	if (tskid == TSK_SELF) {
		p_tcb = p_runtsk;						/*[NGKI1146]*/
	}
	else {
		CHECK_ID(VALID_TSKID(tskid));			/*[NGKI1141]*/
		p_tcb = get_tcb(tskid);
	}

	lock_cpu();
	ercd = p_tcb->actque ? 1 : 0;				/*[NGKI1144]*/
	p_tcb->actque = false;						/*[NGKI1144]*/
	unlock_cpu();

  error_exit:
	LOG_CAN_ACT_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 2
0
ER
prcv_pdq(ID pdqid, intptr_t *p_data, PRI *p_datapri)
{
	PDQCB	*p_pdqcb;
	ER		ercd;

	LOG_PRCV_PDQ_ENTER(pdqid, p_data, p_datapri);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_PDQID(pdqid));
	p_pdqcb = get_pdqcb(pdqid);

	lock_cpu();
	if (receive_pridata(p_pdqcb, p_data, p_datapri)) {
		if (p_runtsk != p_schedtsk) {
			dispatch();
		}
		ercd = E_OK;
	}
	else {
		ercd = E_TMOUT;
	}
	unlock_cpu();

  error_exit:
	LOG_PRCV_PDQ_LEAVE(ercd, p_data, p_datapri);
	return(ercd);
}
Ejemplo n.º 3
0
ER
ini_pdq(ID pdqid)
{
	PDQCB	*p_pdqcb;
	ER		ercd;
    
	LOG_INI_PDQ_ENTER(pdqid);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_PDQID(pdqid));
	p_pdqcb = get_pdqcb(pdqid);

	lock_cpu();
	init_wait_queue(&(p_pdqcb->swait_queue));
	init_wait_queue(&(p_pdqcb->rwait_queue));
	p_pdqcb->count = 0U;
	p_pdqcb->p_head = NULL;
	p_pdqcb->unused = 0U;
	p_pdqcb->p_freelist = NULL;
	if (p_runtsk != p_schedtsk) {
		dispatch();
	}
	ercd = E_OK;
	unlock_cpu();

  error_exit:
	LOG_INI_PDQ_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 4
0
ER
psnd_pdq(ID pdqid, intptr_t data, PRI datapri)
{
	PDQCB	*p_pdqcb;
	ER		ercd;

	LOG_PSND_PDQ_ENTER(pdqid, data, datapri);
	CHECK_UNL();
	CHECK_ID(VALID_PDQID(pdqid));
	p_pdqcb = get_pdqcb(pdqid);
	CHECK_PAR(TMIN_DPRI <= datapri && datapri <= p_pdqcb->p_pdqinib->maxdpri);

	lock_cpu();
	if (send_pridata(p_pdqcb, data, datapri)) {
		if (p_runtsk != p_schedtsk) {
			if (!sense_context()) {
				dispatch();
			}
			else {
				request_dispatch();
			}
		}
		ercd = E_OK;
	}
	else {
		ercd = E_TMOUT;
	}
	unlock_cpu();

  error_exit:
	LOG_PSND_PDQ_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 5
0
ER
stp_alm(ID almid)
{
	ALMCB	*p_almcb;
	ER		ercd;

	LOG_STP_ALM_ENTER(almid);
	CHECK_UNL();
	CHECK_ID(VALID_ALMID(almid));
	p_almcb = get_almcb(almid);

	lock_cpu();
	if (p_almcb->p_alminib->almatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else {
		if (p_almcb->almsta) {
			p_almcb->almsta = false;
			tmevtb_dequeue(&(p_almcb->tmevtb));
		}
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_STP_ALM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 6
0
HRESULT CSWDomeCameraTimer::Set(const DWORD& dwID, const TIMER_PARAM_STRUCT& sSetting)
{
	CHECK_ID(dwID, MAX_TIMER);

	if (sSetting.iBeginTime >= sSetting.iEndTime)
	{
		return E_INVALIDARG;
	}

	if (sSetting.fValid)
	{
		if (sSetting.fEnable)
		{
			StartTimer();
		}
		else if (GetSetting().Get().sTimerParam[dwID].fEnable)
		{
			//stop previous motion
			StopMotion(GetSetting().Get().sTimerParam[dwID].iMotionType, GetSetting().Get().sTimerParam[dwID].iMotionID);
		}
	}
	
	swpa_memcpy(&GetSetting().Get().sTimerParam[dwID], &sSetting, sizeof(GetSetting().Get().sTimerParam[dwID]));
	
	return SaveSetting(dwID);
}
Ejemplo n.º 7
0
ER
get_pri(ID tskid, PRI *p_tskpri)
{
	TCB		*p_tcb;
	ER		ercd;

	LOG_GET_PRI_ENTER(tskid, p_tskpri);
	CHECK_TSKCTX_UNL();							/*[NGKI1203][NGKI1204]*/
	if (tskid == TSK_SELF) {
		p_tcb = p_runtsk;						/*[NGKI1211]*/
	}
	else {
		CHECK_ID(VALID_TSKID(tskid));			/*[NGKI1205]*/
		p_tcb = get_tcb(tskid);
	}

	lock_cpu();
	if (TSTAT_DORMANT(p_tcb->tstat)) {
		ercd = E_OBJ;							/*[NGKI1209]*/
	}
	else {
		*p_tskpri = EXT_TSKPRI(p_tcb->priority);	/*[NGKI1210]*/
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_GET_PRI_LEAVE(ercd, p_tskpri);
	return(ercd);
}
Ejemplo n.º 8
0
ER
wai_sem(ID semid)
{
	SEMCB	*p_semcb;
	WINFO_SEM winfo_sem;
	ER		ercd;

	LOG_WAI_SEM_ENTER(semid);
	CHECK_DISPATCH();
	CHECK_ID(VALID_SEMID(semid));
	p_semcb = get_semcb(semid);

	lock_cpu_dsp();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (p_runtsk->raster) {
		ercd = E_RASTER;
	}
	else if (p_semcb->semcnt >= 1) {
		p_semcb->semcnt -= 1;
		ercd = E_OK;
	}
	else {
		p_runtsk->tstat = TS_WAITING_SEM;
		wobj_make_wait((WOBJCB *) p_semcb, (WINFO_WOBJ *) &winfo_sem);
		dispatch();
		ercd = winfo_sem.winfo.wercd;
	}
	unlock_cpu_dsp();

  error_exit:
	LOG_WAI_SEM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 9
0
ER
sac_sem(ID semid, const ACVCT *p_acvct)
{
	SEMCB	*p_semcb;
	SEMINIB	*p_seminib;
	ER		ercd;

	LOG_SAC_SEM_ENTER(semid, p_acvct);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_SEMID(semid));
	CHECK_MACV_READ(p_acvct, ACVCT);
	p_semcb = get_semcb(semid);

	lock_cpu();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (VIOLATE_ACPTN(p_semcb->p_seminib->acvct.acptn3)) {
		ercd = E_OACV;
	}
	else if (SEMID(p_semcb) <= tmax_ssemid) {
		ercd = E_OBJ;
	}
	else {
		p_seminib = (SEMINIB *)(p_semcb->p_seminib);
		p_seminib->acvct = *p_acvct;
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_SAC_SEM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 10
0
ER
del_sem(ID semid)
{
	SEMCB	*p_semcb;
	SEMINIB	*p_seminib;
	ER		ercd;

	LOG_DEL_SEM_ENTER(semid);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_SEMID(semid));
	p_semcb = get_semcb(semid);

	lock_cpu();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (semid <= tmax_ssemid) {
		ercd = E_OBJ;
	}
	else {
		init_wait_queue(&(p_semcb->wait_queue));
		p_seminib = (SEMINIB *)(p_semcb->p_seminib);
		p_seminib->sematr = TA_NOEXS;
		queue_insert_prev(&free_semcb, &(p_semcb->wait_queue));
		if (p_runtsk != p_schedtsk) {
			dispatch();
		}
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_DEL_SEM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 11
0
Type0Font *
Type0Font_cache_get (int id)
{
  CHECK_ID(id);

  return &__cache.fonts[id];
}
Ejemplo n.º 12
0
ER
ref_mpf(ID mpfid, T_RMPF *pk_rmpf)
{
	MPFCB	*p_mpfcb;
	ER		ercd;
    
	LOG_REF_MPF_ENTER(mpfid, pk_rmpf);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MPFID(mpfid));
	p_mpfcb = get_mpfcb(mpfid);

	lock_cpu();
	if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else {
		pk_rmpf->wtskid = wait_tskid(&(p_mpfcb->wait_queue));
		pk_rmpf->fblkcnt = p_mpfcb->fblkcnt;
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_REF_MPF_LEAVE(ercd, pk_rmpf);
	return(ercd);
}
Ejemplo n.º 13
0
ER
ini_mpf(ID mpfid)
{
	MPFCB	*p_mpfcb;
	ER		ercd;
    
	LOG_INI_MPF_ENTER(mpfid);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MPFID(mpfid));
	p_mpfcb = get_mpfcb(mpfid);

	lock_cpu();
	if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else {
		init_wait_queue(&(p_mpfcb->wait_queue));
		p_mpfcb->fblkcnt = p_mpfcb->p_mpfinib->blkcnt;
		p_mpfcb->unused = 0U;
		p_mpfcb->freelist = INDEX_NULL;
		if (p_runtsk != p_schedtsk) {
			dispatch();
		}
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_INI_MPF_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 14
0
ER
pget_mpf(ID mpfid, void **p_blk)
{
	MPFCB	*p_mpfcb;
	ER		ercd;

	LOG_PGET_MPF_ENTER(mpfid, p_blk);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MPFID(mpfid));
	p_mpfcb = get_mpfcb(mpfid);

	lock_cpu();
	if (p_mpfcb->p_mpfinib->mpfatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (p_mpfcb->fblkcnt > 0) {
		get_mpf_block(p_mpfcb, p_blk);
		ercd = E_OK;
	}
	else {
		ercd = E_TMOUT;
	}
	unlock_cpu();

  error_exit:
	LOG_PGET_MPF_LEAVE(ercd, p_blk);
	return(ercd);
}
Ejemplo n.º 15
0
ER
pol_sem(ID semid)
{
	SEMCB	*p_semcb;
	ER		ercd;

	LOG_POL_SEM_ENTER(semid);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_SEMID(semid));
	p_semcb = get_semcb(semid);

	lock_cpu();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (p_semcb->semcnt >= 1) {
		p_semcb->semcnt -= 1;
		ercd = E_OK;
	}
	else {
		ercd = E_TMOUT;
	}
	unlock_cpu();

  error_exit:
	LOG_POL_SEM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 16
0
ER
ini_sem(ID semid)
{
	SEMCB	*p_semcb;
	ER		ercd;
    
	LOG_INI_SEM_ENTER(semid);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_SEMID(semid));
	p_semcb = get_semcb(semid);

	lock_cpu();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else {
		init_wait_queue(&(p_semcb->wait_queue));
		p_semcb->semcnt = p_semcb->p_seminib->isemcnt;
		if (p_runtsk != p_schedtsk) {
			dispatch();
		}
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_INI_SEM_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 17
0
ER_UINT
can_wup(ID tskid)
{
	TCB		*p_tcb;
	ER_UINT	ercd;

	LOG_CAN_WUP_ENTER(tskid);
	CHECK_TSKCTX_UNL();
	if (tskid == TSK_SELF) {
		p_tcb = p_runtsk;
	}
	else {
		CHECK_ID(VALID_TSKID(tskid));
		p_tcb = get_tcb(tskid);
	}

	lock_cpu();
	if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (TSTAT_DORMANT(p_tcb->tstat)) {
		ercd = E_OBJ;
	}
	else {
		ercd = p_tcb->wupque ? 1 : 0;
		p_tcb->wupque = false;
	}
	unlock_cpu();

  error_exit:
	LOG_CAN_WUP_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 18
0
ER
ref_mtx(ID mtxid, T_RMTX *pk_rmtx)
{
	MTXCB	*p_mtxcb;
	ER		ercd;
    
	LOG_REF_MTX_ENTER(mtxid, pk_rmtx);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MTXID(mtxid));
	CHECK_MACV_WRITE(pk_rmtx, T_RMTX);
	p_mtxcb = get_mtxcb(mtxid);

	lock_cpu();
	if (p_mtxcb->p_mtxinib->mtxatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (VIOLATE_ACPTN(p_mtxcb->p_mtxinib->acvct.acptn4)) {
		ercd = E_OACV;
	}
	else {
		pk_rmtx->htskid = (p_mtxcb->p_loctsk != NULL) ?
								TSKID(p_mtxcb->p_loctsk) : TSK_NONE;
														
		pk_rmtx->wtskid = wait_tskid(&(p_mtxcb->wait_queue));
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_REF_MTX_LEAVE(ercd, pk_rmtx);
	return(ercd);
}
Ejemplo n.º 19
0
ER
ref_mbf(ID mbfid, T_RMBF *pk_rmbf)
{
	MBFCB	*p_mbfcb;
	ER		ercd;
    
	LOG_REF_MBF_ENTER(mbfid, pk_rmbf);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MBFID(mbfid));
	CHECK_MACV_WRITE(pk_rmbf, T_RMBF);
	p_mbfcb = get_mbfcb(mbfid);

	lock_cpu();
	if (p_mbfcb->p_mbfinib->mbfatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (VIOLATE_ACPTN(p_mbfcb->p_mbfinib->acvct.acptn4)) {
		ercd = E_OACV;
	}
	else {
		pk_rmbf->stskid = wait_tskid(&(p_mbfcb->swait_queue));
		pk_rmbf->rtskid = wait_tskid(&(p_mbfcb->rwait_queue));
		pk_rmbf->smbfcnt = p_mbfcb->smbfcnt;
		pk_rmbf->fmbfsz = p_mbfcb->fmbfsz;
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_REF_MBF_LEAVE(ercd, pk_rmbf);
	return(ercd);
}
Ejemplo n.º 20
0
ER
sac_mtx(ID mtxid, const ACVCT *p_acvct)
{
	MTXCB	*p_mtxcb;
	MTXINIB	*p_mtxinib;
	ER		ercd;

	LOG_SAC_MTX_ENTER(mtxid, p_acvct);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_MTXID(mtxid));
	CHECK_MACV_READ(p_acvct, ACVCT);
	p_mtxcb = get_mtxcb(mtxid);

	lock_cpu();
	if (p_mtxcb->p_mtxinib->mtxatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (VIOLATE_ACPTN(p_mtxcb->p_mtxinib->acvct.acptn3)) {
		ercd = E_OACV;
	}
	else if (MTXID(p_mtxcb) <= tmax_smtxid) {
		ercd = E_OBJ;
	}
	else {
		p_mtxinib = (MTXINIB *)(p_mtxcb->p_mtxinib);
		p_mtxinib->acvct = *p_acvct;
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_SAC_MTX_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 21
0
ER
tloc_mtx(ID mtxid, TMO tmout)
{
	MTXCB		*p_mtxcb;
	WINFO_MTX	winfo_mtx;
	TMEVTB		tmevtb;
	ER			ercd;

	LOG_TLOC_MTX_ENTER(mtxid, tmout);
	CHECK_DISPATCH();
	CHECK_ID(VALID_MTXID(mtxid));
	CHECK_PAR(VALID_TMOUT(tmout));
	p_mtxcb = get_mtxcb(mtxid);

	lock_cpu_dsp();
	if (p_mtxcb->p_mtxinib->mtxatr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else if (VIOLATE_ACPTN(p_mtxcb->p_mtxinib->acvct.acptn1)) {
		ercd = E_OACV;
	}
	else if (MTX_CEILING(p_mtxcb)
			&& p_mtxcb->p_mtxinib->ceilpri < p_runtsk->p_dominib->minpriority
			&& VIOLATE_ACPTN(p_runtsk->p_dominib->acvct.acptn2)) {
		ercd = E_OACV;									/*[NGKI5124]*/
	}
	else if (p_runtsk->raster) {
		ercd = E_RASTER;
	}
	else if (MTX_CEILING(p_mtxcb)
				&& p_runtsk->bpriority < p_mtxcb->p_mtxinib->ceilpri) {
		ercd = E_ILUSE;
	}
	else if (p_mtxcb->p_loctsk == NULL) {
		mutex_acquire(p_runtsk, p_mtxcb);
		/*
		 *  優先度上限ミューテックスをロックした場合,p_runtskの優先度
		 *  が上がる可能性があるが,ディスパッチが必要になることはない.
		 */
		assert(p_runtsk == p_schedtsk);
		ercd = E_OK;
	}
	else if (p_mtxcb->p_loctsk == p_runtsk) {
		ercd = E_OBJ;
	}
	else if (tmout == TMO_POL) {
		ercd = E_TMOUT;
	}
	else {
		wobj_make_wait_tmout((WOBJCB *) p_mtxcb, TS_WAITING_MTX,
								(WINFO_WOBJ *) &winfo_mtx, &tmevtb, tmout);
		dispatch();
		ercd = winfo_mtx.winfo.wercd;
	}
	unlock_cpu_dsp();

  error_exit:
	LOG_TLOC_MTX_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 22
0
ER
ref_alm(ID almid, T_RALM *pk_ralm)
{
    ALMCB	*p_almcb;
    ER		ercd;

    LOG_REF_ALM_ENTER(almid, pk_ralm);
    CHECK_TSKCTX_UNL();
    CHECK_ID(VALID_ALMID(almid));
    p_almcb = get_almcb(almid);

    lock_cpu();
    if (p_almcb->almsta) {
        pk_ralm->almstat = TALM_STA;
        pk_ralm->lefttim = tmevt_lefttim(&(p_almcb->tmevtb));
    }
    else {
        pk_ralm->almstat = TALM_STP;
    }
    ercd = E_OK;
    unlock_cpu();

error_exit:
    LOG_REF_ALM_LEAVE(ercd, pk_ralm);
    return(ercd);
}
Ejemplo n.º 23
0
ER
sta_alm(ID almid, RELTIM almtim)
{
    ALMCB	*p_almcb;
    ER		ercd;

    LOG_STA_ALM_ENTER(almid, almtim);
    CHECK_UNL();
    CHECK_ID(VALID_ALMID(almid));
    CHECK_PAR(VALID_RELTIM(almtim));
    p_almcb = get_almcb(almid);

    lock_cpu();
    if (p_almcb->almsta) {
        tmevtb_dequeue(&(p_almcb->tmevtb));
    }
    else {
        p_almcb->almsta = true;
    }
    tmevtb_enqueue(&(p_almcb->tmevtb), almtim);
    ercd = E_OK;
    unlock_cpu();

error_exit:
    LOG_STA_ALM_LEAVE(ercd);
    return(ercd);
}
Ejemplo n.º 24
0
ER
get_mpf(ID mpfid, void **p_blk)
{
	MPFCB	*p_mpfcb;
	WINFO_MPF winfo_mpf;
	ER		ercd;

	LOG_GET_MPF_ENTER(mpfid, p_blk);
	CHECK_DISPATCH();
	CHECK_ID(VALID_MPFID(mpfid));
	p_mpfcb = get_mpfcb(mpfid);

	lock_cpu_dsp();
	if (p_runtsk->raster) {
		ercd = E_RASTER;
	}
	else if (p_mpfcb->fblkcnt > 0) {
		get_mpf_block(p_mpfcb, p_blk);
		ercd = E_OK;
	}
	else {
		p_runtsk->tstat = TS_WAITING_MPF;
		wobj_make_wait((WOBJCB *) p_mpfcb, (WINFO_WOBJ *) &winfo_mpf);
		dispatch();
		ercd = winfo_mpf.winfo.wercd;
		if (ercd == E_OK) {
			*p_blk = winfo_mpf.blk;
		}
	}
	unlock_cpu_dsp();

  error_exit:
	LOG_GET_MPF_LEAVE(ercd, p_blk);
	return(ercd);
}
Ejemplo n.º 25
0
ER
ref_sem(ID semid, T_RSEM *pk_rsem)
{
	SEMCB	*p_semcb;
	ER		ercd;
    
	LOG_REF_SEM_ENTER(semid, pk_rsem);
	CHECK_TSKCTX_UNL();
	CHECK_ID(VALID_SEMID(semid));
	p_semcb = get_semcb(semid);

	lock_cpu();
	if (p_semcb->p_seminib->sematr == TA_NOEXS) {
		ercd = E_NOEXS;
	}
	else {
		pk_rsem->wtskid = wait_tskid(&(p_semcb->wait_queue));
		pk_rsem->semcnt = p_semcb->semcnt;
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_REF_SEM_LEAVE(ercd, pk_rsem);
	return(ercd);
}
Ejemplo n.º 26
0
ER
sus_tsk(ID tskid)
{
	TCB		*p_tcb;
	ER		ercd;

	LOG_SUS_TSK_ENTER(tskid);
	CHECK_TSKCTX_UNL();							/*[NGKI1299][NGKI1300]*/
	if (tskid == TSK_SELF) {
		p_tcb = p_runtsk;						/*[NGKI1310]*/
	}
	else {
		CHECK_ID(VALID_TSKID(tskid));			/*[NGKI1302]*/
		p_tcb = get_tcb(tskid);
	}

	lock_cpu();
	if (p_tcb == p_runtsk && !dspflg) {			/*[NGKI1311][NGKI3604]*/
		ercd = E_CTX;
	}
	else if (p_tcb->p_tinib->tskatr == TA_NOEXS) {
		ercd = E_NOEXS;							/*[NGKI1303]*/
	}
	else if (TSTAT_DORMANT(p_tcb->tstat)) {
		ercd = E_OBJ;							/*[NGKI1305]*/
	}
	else if (p_tcb->raster) {
		ercd = E_RASTER;						/*[NGKI3605]*/
	}
	else if (TSTAT_RUNNABLE(p_tcb->tstat)) {
		/*
		 *  実行できる状態から強制待ち状態への遷移[NGKI1307]
		 */
		p_tcb->tstat = TS_SUSPENDED;
		LOG_TSKSTAT(p_tcb);
		make_non_runnable(p_tcb);
		if (p_runtsk != p_schedtsk) {
			dispatch();
		}
		ercd = E_OK;
	}
	else if (TSTAT_SUSPENDED(p_tcb->tstat)) {
		ercd = E_QOVR;							/*[NGKI1306]*/
	}
	else {
		/*
		 *  待ち状態から二重待ち状態への遷移[NGKI1308]
		 */
		p_tcb->tstat |= TS_SUSPENDED;
		LOG_TSKSTAT(p_tcb);
		ercd = E_OK;
	}
	unlock_cpu();

  error_exit:
	LOG_SUS_TSK_LEAVE(ercd);
	return(ercd);
}
Ejemplo n.º 27
0
/* close communication with mainframe under logical number 'id'
   and stop thread */
int
sy527Stop(unsigned id)
{
  char name[MAX_NAME];
  int i, j, ret;

  /* lock global mutex to prevent other mainframes to be stoped
     until we are done with this one */
  LOCK_GLOBAL;

  CHECK_ID(id);
  CHECK_OPEN(id);
  strcpy(name, Measure[id]->name);


  /* stop thread */
  force_exit[id] = 1;


  ret = CAENHVDeinitSystem(name);

  if(ret == CAENHV_OK)
  {
    printf("\nConnection >%s< closed (num. %d)\n\n", name,ret);
    Measure[id]->id = -1;
  }
  else
  {
    printf("\nERROR(sy527): %s (num. %d)\n\n", CAENHVGetError(name), ret);
    UNLOCK_GLOBAL;

    return(CAENHV_SYSERR);
  }

  /* unregister mainframe */
  j = -1;
  for(i=0; i<nmainframes; i++)
  {
    if(mainframes[i] == id)
    {
      j = i;
      break;
    }
  }
  if(j==-1)
  {
    printf("ERROR: mainframe %d was not registered\n",id);
    UNLOCK_GLOBAL;

    return(CAENHV_SYSERR);
  }
  for(i=j; i<nmainframes; i++) mainframes[i] = mainframes[i+1];
  nmainframes --;

  UNLOCK_GLOBAL;

  return(CAENHV_OK);
}
Ejemplo n.º 28
0
HRESULT CSWDomeCameraTimer::Get(const DWORD& dwID, TIMER_PARAM_STRUCT& sSetting)
{
	CHECK_ID(dwID, MAX_TIMER);

	swpa_memcpy(&sSetting, &GetSetting().Get().sTimerParam[dwID], sizeof(sSetting));

	//SW_TRACE_DEBUG("tobemarked: get timer %d: MotionType=%d, MotionID=%d\n", dwID, GetSetting().Get().sTimerParam[dwID].iMotionType,
	//	GetSetting().Get().sTimerParam[dwID].iMotionID);
		
	return S_OK;
}
static int msm_bus_board_8064_get_iid(int id)
{
	if ((id < SLAVE_ID_KEY && id >= NMASTERS) ||
		id >= (SLAVE_ID_KEY + NSLAVES)) {
		MSM_BUS_ERR("Cannot get iid. Invalid id %d passed\n", id);
		return -EINVAL;
	}

	return CHECK_ID(((id < SLAVE_ID_KEY) ? master_iids[id] :
		slave_iids[id - SLAVE_ID_KEY]), id);
}
static int msm_bus_get_iid(int id)
{
	if ((id < SLAVE_ID_KEY && id >= MSM_BUS_MASTER_LAST) ||
		id >= MSM_BUS_SLAVE_LAST) {
		MSM_BUS_ERR("Cannot get iid. Invalid id %d passed\n", id);
		return -EINVAL;
	}

	return CHECK_ID(((id < SLAVE_ID_KEY) ? master_iids[id] :
		slave_iids[id - SLAVE_ID_KEY]), id);
}