noknl3s.c

NORTi3 is a realtime multitasking operating system conforming to the micro-ITRON 3.0 specification.

  #endif
    if (blfsz < SIZEOF_PTR)
        blfsz = SIZEOF_PTR;
  #if (ERC && SIZEOF_PTR <= 2)
    allsz = (UW)blfsz * pk_cmpf->mpfcnt;
    if (allsz > 0xffffUL)
        return SYSER = E_PAR;
  #else
    allsz = (size_t)blfsz * pk_cmpf->mpfcnt;
  #endif
    dis_ims();
    mpf = &MPF[mpfid];
    if (mpf->allad != NULL)
    {   ret_ims2();
        return E_OBJ;
    }
    blf = mpl_alloc((size_t)allsz);
    if (blf == NULL)
    {   ret_ims2();
        return SYSER = E_NOMEM;
    }
    mpf->allad = blf;
    mpf->cnt += pk_cmpf->mpfcnt;
    for (i = pk_cmpf->mpfcnt - 1; i != 0; i--)
        blf = *(B **)blf = blf + blfsz;
    *(B **)blf = mpf->top;
    mpf->top = mpf->allad;

    for(disp = FALSE; mpf->que[0] != 0;)
    {   tskid = mpf->que[0];
        tcb = &TCB[tskid];
        if (mpf->top == NULL)
            break;
        blf = mpf->top;
        tcb->sp->ptr = blf;
        mpf->top = *(B **)blf;
        mpf->cnt--;
        if (tcb->sts & S_TMO)
            del_tmq(tcb, tskid);
        tcb->sts = S_RDY;
        if (tcb->sus == 0)
        {   pri = tcb->pri;
            if (pri < NOWPRI)
                disp = TRUE;
            chg_que((UB NEAR *)RDQ + pri, tcb, tskid);
        }
        else
            del_que(tcb, tskid);
    }
    if (disp == TRUE)
        return dispatch();
    return_ret_ims();
}

#endif
#ifdef TGET_BLF
/************************************************/
/* Get Fixed-size Memory Block with Timeout     */
/************************************************/

ER v3_tget_blf(B **p_blf, ID mpfid, TMO tmout)
{
    T_MPF NEAR *mpf;
    T_TCB NEAR *tcb;
    B *blf;
    ID tskid;
    UB NEAR *que;

  #if ERC
    if (mpfid == 0)
        return SYSER = E_ID;
    else if (mpfid > CFG.mpfid_max)
        return SYSER = E_ID;
  #endif
    dis_ims();
    mpf = &MPF[mpfid];
    if (mpf->top == NULL)
    {   if (tmout != TMO_POL)
        {
          #if ERC
            if ((INEST)||(DDISP)||(RDQ[0] == (UB)(CFG.tskid_max+1)))
            {   ret_ims2();
                return SYSER = E_CTX;
            }
          #endif
            tskid = RDQ[0];
            tcb = &TCB[tskid];
            if (tmout != TMO_FEVR)
            {   add_tmq(tmout, tcb, tskid);
                tcb->sts = (UB)(S_MPF|S_TMO);
            }
            else
                tcb->sts = S_MPF;
            CTXPTR = p_blf;
            que = mpf->que;
            return chg_que_dispatch1(que, tcb, tskid);
        }
        ret_ims2();
        return E_TMOUT;
    }
    blf = mpf->top;
    *p_blf = blf;
    mpf->top = *(B **)blf;
    mpf->cnt--;
    return_ret_ims();
}

#endif
#ifdef REL_BLF
/************************************************/
/* Release Fixed-size Memory Block              */
/************************************************/

ER v3_rel_blf(ID mpfid, VP blf)
{
    T_MPF NEAR *mpf;
    T_TCB NEAR *tcb;
    ID tskid;

  #if ERC
    if (mpfid == 0)
        return SYSER = E_ID;
    else if (mpfid > CFG.mpfid_max)
        return SYSER = E_ID;
  #endif
    dis_ims();
    mpf = &MPF[mpfid];
    if (mpf->top == NULL)
    {   tskid = mpf->que[0];
        if (tskid != 0)
        {   tcb = &TCB[tskid];
            *(B **)tcb->sp->ptr = (B *)blf;
            if (tcb->sts & S_TMO)
                del_tmq(tcb, tskid);
            tcb->sts = S_RDY;
            if (tcb->sus == 0)
                return chg_rdq_dispatch(tcb, tskid);
            else
                return del_que_ret_ims(tcb, tskid);
        }
        *(B **)blf = NULL;
        mpf->top = blf;
        mpf->cnt = 1;
        return_ret_ims();
    }
    *(B **)blf = mpf->top;
    mpf->top = blf;
    mpf->cnt++;
    return_ret_ims();
}

#endif
#ifdef REF_MPF
/************************************************/
/* Refer Fixed-size MemoryPool Status           */
/************************************************/

ER v3_ref_mpf(T_RMPF *pk_rmpf, ID mpfid)
{
    T_MPF NEAR *mpf;
    ID tskid;

  #if ERC
    if (mpfid == 0)
        return SYSER = E_ID;
    else
  #endif
    if (mpfid > CFG.mpfid_max)
        return E_ID;
    dis_ims();
    mpf = &MPF[mpfid];
    pk_rmpf->exinf = 0;
    pk_rmpf->frbcnt = mpf->cnt;
    if (mpf->top == NULL)
    {   tskid = mpf->que[0];
        if (tskid != 0)
        {   pk_rmpf->wtsk = tskid;
            return_ret_ims();
        }
    }
    pk_rmpf->wtsk = FALSE;
    return_ret_ims();
}

#endif
#ifdef SET_TIM
/************************************************/
/* Set Time                                     */
/************************************************/

ER v3_set_tim(const SYSTIME *pk_tim)
{
    dis_ims();
  #if (CLKBITS>32)
    SYSCK.utime = pk_tim->utime;
  #endif
    SYSCK.ltime = pk_tim->ltime;
    return_ret_ims();
}

#endif
#ifdef GET_TIM
/************************************************/
/* Get Time                                     */
/************************************************/

ER v3_get_tim(SYSTIME *pk_tim)
{
    dis_ims();
  #if (CLKBITS>32)
    pk_tim->utime = SYSCK.utime;
  #endif
    pk_tim->ltime = SYSCK.ltime;
    return_ret_ims();
}

#endif
#ifdef DLY_TSK
/************************************************/
/* Delay Task                                   */
/************************************************/

ER v3_dly_tsk(DLYTIME dlytim)
{
    T_TCB NEAR *tcb;
    ID tskid;

  #if ERC
    if ((INEST)||(DDISP)||(RDQ[0] == (UB)(CFG.tskid_max+1)))
        return SYSER = E_CTX;
  #endif
    tskid = RDQ[0];
    tcb = &TCB[tskid];
    dis_ims();
    if (dlytim != 0)
    {   add_tmq(dlytim, tcb, tskid);
        tcb->sts = (UB)(S_DLY|S_TMO);
        return del_que_dispatch1(tcb, tskid);
    }
    ret_ims2();
    return E_OK;
}

#endif
#ifdef DEF_CYC
/************************************************/
/* Define Cyclic Handler                        */
/************************************************/

ER v3_def_cyc(HNO cycno, const T_DCYC *pk_dcyc)
{
    T_CYC NEAR *cyc;

  #if ERC
    if (INEST)
        return SYSER = E_CTX;
    if (cycno == 0)
        return SYSER = E_PAR;
    else if (cycno > CFG.cycno_max)
        return SYSER = E_PAR;
    if (pk_dcyc != (T_DCYC *)NADR && pk_dcyc->cycact & ~(TCY_ON|TCY_OFF))
        return SYSER = E_PAR;
  #endif
    dis_ims();
    cyc = &CYC[cycno];
    if (pk_dcyc == (T_DCYC *)NADR)
    {   if (cyc->dcyc != NULL)
        {   del_cycq(cyc, cycno);
            cyc->dcyc = NULL;
        }
        ret_ims2();
        return E_OK;
    }
    if (cyc->dcyc != NULL)
        del_cycq(cyc, cycno);
    cyc->dcyc = pk_dcyc;
    cyc->ntm = 0;
    cyc->ptm = 0;
    tim_add(&pk_dcyc->cyctim, &SYSCK, cyc);
    cyc->cycact = (UINT)pk_dcyc->cycact;
    add_cycq(cyc, cycno);
    return_ret_ims();
}

#endif
#ifdef ACT_CYC
/************************************************/
/* Activate Cyclic Handler                      */
/************************************************/

ER v3_act_cyc(HNO cycno, UINT cycact)
{
    T_CYC NEAR *cyc;

  #if ERC
    if (cycno == 0)
        return SYSER = E_PAR;
    else if (cycno > CFG.cycno_max)
        return SYSER = E_PAR;
    if (cycact & ~(TCY_ON|TCY_OFF|TCY_INI))
        return SYSER = E_PAR;
  #endif
    dis_ims();
    cyc = &CYC[cycno];
    if (cyc->dcyc == NULL)
    {   ret_ims2();
        return E_NOEXS;
    }
    cyc->cycact = cycact;
    if (cycact & TCY_INI)
    {   del_cycq(cyc, cycno);
        cyc->ntm = 0;
        cyc->ptm = 0;
        tim_add(&cyc->dcyc->cyctim, &SYSCK, cyc);
        add_cycq(cyc, cycno);
    }
    return_ret_ims();
}

#endif
#ifdef REF_CYC
/************************************************/
/* Refer Cyclic Handler Status                  */
/************************************************/

ER v3_ref_cyc(T_RCYC *pk_rcyc, HNO cycno)
{
    T_CYC NEAR *cyc;
    SYSTIME now;

  #if ERC
    if (cycno == 0)
        return SYSER = E_PAR;
    else
  #endif
    if (cycno > CFG.cycno_max)
        return E_PAR;
    dis_ims();
    cyc = &CYC[cycno];
    if (cyc->dcyc == NULL)
    {   ret_ims2();
        return E_NOEXS;
    }
  #if (CLKBITS>32)
    now.utime = SYSCK.utime;
  #endif
    now.ltime = SYSCK.ltime;
    pk_rcyc->exinf = cyc->dcyc->exinf;
    tim_dif(&now, cyc, &pk_rcyc->lfttim);
    pk_rcyc->cycact = (UINT)(cyc->cycact & (TCY_ON | TCY_OFF));
    return_ret_ims();
}

#endif
#ifdef DEF_ALM
/************************************************/
/* Define Alarm Handler                         */
/************************************************/

ER v3_def_alm(HNO almno, const T_DALM *pk_dalm)
{
    T_ALM NEAR *alm;

  #if ERC
    if (INEST)
        return SYSER = E_CTX;
    if (almno == 0)
        return SYSER = E_PAR;
    else if (almno > CFG.almno_max)
        return SYSER = E_PAR;
    if (pk_dalm != (T_DALM *)NADR && pk_dalm->tmmode & ~(TTM_ABS|TTM_REL))
        return SYSER = E_PAR;
  #endif
    dis_ims();
    alm = &ALM[almno];
    if (pk_dalm == (T_DALM *)NADR)
    {   if (alm->dalm != NULL)
        {   del_almq(alm, almno);
            alm->dalm = NULL;
        }
        ret_ims2();
        return E_OK;
    }
    if (alm->dalm != NNULL)
        del_almq(alm, almno);
    alm->dalm = pk_dalm;
    alm->ntm = 0;
    alm->ptm = 0;
    if (pk_dalm->tmmode == TTM_REL)
        tim_add(&pk_dalm->almtim, &SYSCK, (T_CYC NEAR *)alm);
    else
    {
      #if (CLKBITS>32)
        alm->utime = pk_dalm->almtim.utime;
      #endif
        alm->ltime = pk_dalm->almtim.ltime;
    }
    add_almq(alm, almno);
    return_ret_ims();
}

#endif
#ifdef REF_ALM
/************************************************/
/* Refer Alarm Handler Status                   */
/************************************************/

ER v3_ref_alm(T_RALM *pk_ralm, HNO almno)
{
    T_ALM NEAR *alm;
    SYSTIME now;

  #if ERC
    if (almno == 0)
        return SYSER = E_PAR;
    else
  #endif
    if (almno > CFG.almno_max)
        return E_PAR;
    dis_ims();
    alm = &ALM[almno];
    if (alm->dalm == NULL)
    {   ret_ims2();
        return E_NOEXS;
    }
    pk_ralm->exinf = alm->dalm->exinf;
  #if (CLKBITS>32)
    now.utime = SYSCK.utime;
  #endif
    now.ltime = SYSCK.ltime;
    tim_dif(&now, (T_CYC NEAR *)alm, &pk_ralm->lfttim);
    return_ret_ims();
}

#endif
#ifdef GET_VER
/************************************************/
/* Get Version Information                      */
/************************************************/

ER v3_get_ver(T_VER *pk_ver)
{
    *pk_ver = *norti_ver;
    return E_OK;
}

#endif
#ifdef REF_SYS
/************************************************/
/* Refer System Status                          */
/************************************************/

ER v3_ref_sys(T_RSYS *pk_rsys)
{
    UINT imask;

    if (INEST < 0)
        pk_rsys->sysstat = TSS_INDP;
    else
    {   if (DDISP != 0)
        {   dis_ims();
            imask = IMASK;
            ret_ims2();

            if (ref_sys_sub(imask))
                pk_rsys->sysstat = TSS_LOC;
            else
                pk_rsys->sysstat = TSS_DDSP;
        }
        else
            pk_rsys->sysstat = TSS_TSK;
    }
    return E_OK;
}

#endif
#ifdef REF_CFG
/************************************************/
/* Refer Configuration Information              */
/************************************************/

ER v3_ref_cfg(T_RCFG *pk_rcfg)
{
    pk_rcfg->tskid_max = CFG.tskid_max;
    pk_rcfg->semid_max = CFG.semid_max;
    pk_rcfg->flgid_max = CFG.flgid_max;
    pk_rcfg->mbxid_max = CFG.mbxid_max;
    pk_rcfg->mbfid_max = CFG.mbfid_max;
    pk_rcfg->porid_max = CFG.porid_max;
    pk_rcfg->mplid_max = CFG.mplid_max;
    pk_rcfg->mpfid_max = CFG.mpfid_max;
    pk_rcfg->cycno_max = CFG.cycno_max;
    pk_rcfg->almno_max = CFG.almno_max;
    pk_rcfg->tpri_max  = CFG.tpri_max;
    pk_rcfg->tmrqsz    = CFG.tmrqsz;
    pk_rcfg->cycqsz    = CFG.cycqsz;
    pk_rcfg->almqsz    = CFG.almqsz;
    pk_rcfg->istksz    = CFG.istksz;
    pk_rcfg->tstksz    = CFG.tstksz;
    pk_rcfg->sysmsz    = CFG.sysmsz;
    pk_rcfg->mplmsz    = CFG.mplmsz;
    pk_rcfg->stkmsz    = CFG.stkmsz;
    return E_OK;
}

#endif
#ifdef OS_CORE
/************************************************/
/* System Clock                                 */
/************************************************/

void sig_tim(void)
{
    TCB[CFG.tskid_max+1].pri = 0;
    SDISP = (UB)(CFG.tskid_max+1);
    TMREQ++;
    DELAY = 1;
}

#endif
#ifdef OS_CORE
/************************************************/
/* Add Time                                     */
/************************************************/

void NEAR tim_add(const SYSTIME *t1, const SYSTIME *t2, T_CYC NEAR *add)
{
    add->ltime = t1->ltime + t2->ltime;
  #if (CLKBITS>32)
    add->utime = t1->utime + t2->utime;