ros33.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

        g_sMsgbufcb[i].bufend = 0;
        g_sMsgbufcb[i].head = 0;  
        g_sMsgbufcb[i].tail = 0;  
        g_sMsgbufcb[i].maxmsz = 0;
        g_sMsgbufcb[i].ubEmpty = 1;
    }

    // init variable memory pool 
    for(i = 0; i < MPLBLK_NUM; i++){
        mInitMember((T_NODE*)&(g_sMplcb[i].pNxtTsk));
        g_sMplcb[i].StartAlloc = 0;   
        g_sMplcb[i].EndAlloc = 0;
        g_sMplcb[i].NxtAlcp = 0;  
        g_sMplcb[i].TblPtr = 0;  
        g_sMplcb[i].ulRow = 0;
        g_sMplcb[i].ulBlksz = 0;
    }

    // init fixed memory pool 
    for(i = 0; i < MPFBLK_NUM; i++){
        mInitMember((T_NODE*)&(g_sMpfcb[i].pNxtTsk));
        g_sMpfcb[i].StartAlloc = 0;   
        g_sMpfcb[i].EndAlloc = 0;
        g_sMpfcb[i].NxtAlcp = 0;  
        g_sMpfcb[i].TblPtr = 0;  
        g_sMpfcb[i].ulRow = 0;
        g_sMpfcb[i].ulBlksz = 0;
    }

    // init cyclic handler control block 
    for(i = 0; i < CYCHNDR_NUM; i++){
        mInitMember((T_NODE*)&(g_sCycHndrcb[i].pNxtTimeHndr));
        g_sCycHndrcb[i].fpPC = 0;   
        g_sCycHndrcb[i].cycact = 0;
        g_sCycHndrcb[i].tmmode = 0;
        g_sCycHndrcb[i].Iniltime = 0;  
        g_sCycHndrcb[i].Iniutime = 0;  
        g_sCycHndrcb[i].ltime = 0;
        g_sCycHndrcb[i].utime = 0;
        g_sCycHndrcb[i].ubHndrStat = 0;
    }

    // init alarm handler control block 
    for(i = 0; i < ALMHNDR_NUM; i++){
        mInitMember((T_NODE*)&(g_sAlmHndrcb[i].pNxtTimeHndr));
        g_sAlmHndrcb[i].fpPC = 0;   
        g_sAlmHndrcb[i].cycact = 0;
        g_sAlmHndrcb[i].tmmode = 0;
        g_sAlmHndrcb[i].Iniltime = 0;  
        g_sAlmHndrcb[i].Iniutime = 0;  
        g_sAlmHndrcb[i].ltime = 0;
        g_sAlmHndrcb[i].utime = 0;
        g_sAlmHndrcb[i].ubHndrStat = 0;
    }

    // init task control block 
    for(i = 0; i < TSK_NUM; i++){
        mInitMember((T_NODE*)&(g_sTskcb[i].pNxtTsk));
        mInitMember((T_NODE*)&(g_sTskcb[i].pNxtTmoTsk));
        g_sTskcb[i].uwSP = 0;   
        g_sTskcb[i].uwIniSP = 0;   
        g_sTskcb[i].fpPC = 0;   
        g_sTskcb[i].ltime = 0;   
        g_sTskcb[i].utime = 0;   
        g_sTskcb[i].uhWupcnt = 0;   
        g_sTskcb[i].bPriority = 0;   
        g_sTskcb[i].bIniPriority = 0;   
        g_sTskcb[i].ubIntinfo = 0;   
        g_sTskcb[i].ubStatus = 0;   
        g_sTskcb[i].ubWaitStat = 0;   
    }
}

//********************************************************************
//  Start Multi Task
//  [Parameters]
//      none
//  [Return Parameters]
//      none
//      This function not return user main function.
//      If system stop, you have to use priority low level task.
//      
//
//  stack usage
//      | main      | address high
//      | DumyTskcb |
//      |    :      |
//      | user task |
//      |    :      |
//      |    :      | address low
//********************************************************************
void sys_sta
    (
    )
{
    T_TSKCB     sDumyTskcb;

    g_pCurTsk = &sDumyTskcb;

    #ifdef DEBUG_KERNEL
    sDumyTskcb.uwIniSP = (UW)&sDumyTskcb + sizeof(T_TSKCB);
    #endif
    
    g_ubSysStat &= ~TSS_LOC;    // same unl_cpu function

    /* enable interrupt */      
    //ENABLE_INT;
    
    g_blDelay = 0;              // first dispach is special
    schedule();           //
}

//***********************************************************************
//    debug routine
//***********************************************************************
#ifdef DEBUG_KERNEL
void prt_tskid()
{
    ros_dbg_tskcng(g_pCurTsk-g_sTskcb+1);
}
#endif


//********************************************************************
//  Create Msgbuf
//  [Parameters]
//      ID  mbfid   Message buffer ID
//      VP  msgbuf  Message buffer pointer
//      INT bufsz   buffer size
//      INT maxmsz  Max message size
//  [Return Parameters]
//      ER      ercd    ErrorCode
//********************************************************************
ER vcre_mbf
    (
    ID  mbfid,
    VP  msgbuf,
    INT bufsz,
    INT maxmsz
    )
{
    T_MSGBUFCB* pMsgbufcb;

#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif

#ifndef NO_ERROR_CHECK
    if(mbfid <= 0)
    {
        return E_ID;
    }

    if(mbfid > MSGBUF_NUM)
    {
        return E_NOEXS;
    }

    if(maxmsz <= 0)
    {
        return E_PAR;
    }

    if((bufsz < maxmsz+4) && (bufsz != 0))
    {
        return E_PAR;
    }
#endif

    pMsgbufcb = &g_sMsgbufcb[mbfid-1];

    pMsgbufcb->bufst = msgbuf;
    pMsgbufcb->bufend = (char*)msgbuf + bufsz;
    pMsgbufcb->head = msgbuf;
    pMsgbufcb->tail = msgbuf;
    pMsgbufcb->maxmsz = maxmsz;
    
#ifndef NO_RETURN_VALUE
    return E_OK;
#endif
}
    
//********************************************************************
//  Change semapho count
//  [Parameters]
//      ID  semid   Semapho ID
//      UB  semcnt  Semapho count
//  [Return Parameters]
//      ER      ercd    ErrorCode
//********************************************************************

ER vchg_semcnt(ID semid, UB semcnt)
{
#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif
    
#ifndef NO_ERROR_CHECK
    if(semid <= 0)
    {
        return E_ID;
    }
    
    if(semid > SMPH_NUM)
    {
        return E_NOEXS;
    }
#endif

    g_sSmphcb[semid-1].ubSmphMax = semcnt;
    g_sSmphcb[semid-1].ubSmphCnt = semcnt;

    return E_OK;
}


//********************************************************************
//  Check timer wait task (wait time_out or dly tsk)
//  [Parameters]
//  [Return Parameters]
//      1 exist timer wait task
//      0 not exist timer wait task
//********************************************************************

int vchk_timer
    (
    )
{
#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif

    if((T_TIMEOUTTSK *)(g_sTimeOutTsk.pNxtTimeOutTsk) != &g_sTimeOutTsk)
        return 1;

    return 0;
}

//********************************************************************
//  Create Variabie Memory Pool
//  [Parameters]
//      ID  mplid      Variabie Memory Pool ID
//      VP  start_addr Memory Pool start address
//      VP  end_addr   Memory Pool end address
//  [Return Parameters]
//      ER      ercd    ErrorCode
//********************************************************************
ER vcre_mpl
    (
    ID  mplid,
    VP  start_addr,
    VP  end_addr
    )
{
#if 0 //gfdmodified
    T_MPLCB* pMplcb;

    UW       ulStaddrwk;
    UW       ulEndaddrwk;

#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif

#ifndef NO_ERROR_CHECK
    if(mplid <= 0)
    {
        return E_ID;
    }

    if(mplid > MPLBLK_NUM)
    {
        return E_NOEXS;
    }
#endif

    ulStaddrwk =(UW)(start_addr + 3) & 0xfffffffc;
    ulEndaddrwk = (UW)end_addr & 0xfffffffc;

#ifndef NO_ERROR_CHECK
    if(ulStaddrwk + 8 >= ulEndaddrwk)
    {
        return E_PAR;
    }
#endif

    pMplcb = &g_sMplcb[mplid-1];

    pMplcb->StartAlloc = (VP)ulStaddrwk;
    pMplcb->EndAlloc = (VP)ulEndaddrwk;
    pMplcb->NxtAlcp = (VP)ulStaddrwk;
    pMplcb->TblPtr = (VP)ulEndaddrwk;
    pMplcb->ulRow = 0;
    pMplcb->ulBlksz = 0;
#endif
    return E_OK;
}
//////added for gfd
//********************************************************************
//  Create Fixed Memory Pool
//  [Parameters]
//      ID  mpfid      Fixed Memory Pool ID
//      VP  start_addr Memory Pool start address
//      VP  end_addr   Memory Pool end address
//      INT blfsz      Fixed Block size
//  [Return Parameters]
//      ER      ercd    ErrorCode
//********************************************************************
ER vcre_mpf
    (
    ID  mpfid,
    VP  start_addr,
    VP  end_addr,
    INT blfsz
    )
{
#if 0 //gfdmodified
    T_MPLCB* pMpfcb;

    UW       ulStaddrwk;
    UW       ulEndaddrwk;

#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif

#ifndef NO_ERROR_CHECK
    if(mpfid <= 0)
    {
        return E_ID;
    }

    if(mpfid > MPFBLK_NUM)
    {
        return E_NOEXS;
    }

    if(blfsz <= 0)
    {
        return E_PAR;
    }
#endif

    ulStaddrwk = (UW)(start_addr + 3) & 0xfffffffc;
    ulEndaddrwk = (UW)end_addr & 0xfffffffc;

    blfsz = ( blfsz + 3 ) & 0xfffffffc;

#ifndef NO_ERROR_CHECK
    if(ulStaddrwk + blfsz + 8 > ulEndaddrwk)
    {
        return E_PAR;
    }
#endif

    pMpfcb = &g_sMpfcb[mpfid-1];

    pMpfcb->StartAlloc = (VP)ulStaddrwk;
    pMpfcb->EndAlloc = (VP)ulEndaddrwk;
    pMpfcb->NxtAlcp = (VP)ulStaddrwk;
    pMpfcb->TblPtr = (VP)ulEndaddrwk;
    pMpfcb->ulRow = 0;
    pMpfcb->ulBlksz = blfsz;
#endif
    return E_OK;
}