ros33.c

最近在國外網站抓到的作業系統 以Arm為基礎去開發的

//*************************************************************************
//
//  Copyright (C) SEIKO EPSON CORP. 1997
//  All Rights Reserved
//
//  Filename : ros33.c       Please compile this source use -O option.
//  Function : for C33 itron
//  Revision :
//          1997/08/01  H.Matsuoka  start
//          1998/04/08  H.Matsuoka  Move some global value to ros33asm.s
//          1999/08/26  H.Matsuoka  Add message buffer function, bug fix
//          1999/09/29  H.Matsuoka  interrupt mask by IL
//          1999/10/18  H.Matsuoka  Add semapho count change function
//          1999/11/25  H.Matsuoka  Change ent_int to assembler
//          2000/02/23  H.Matsuoka  Fix suspend status problem
//          2000/02/23  H.Matsuoka  Fix rcv_mbf problem
//          2000/11/21  Y.Taka      Add memory pool management
//          2000/12/20  Y.Taka      Add Enter/Return_critical_section
//          2001/02/07  Y.Taka      16bit of flag & cyclic/alarm handler
//          2001/03/08  Y.Taka      Del critical section sub.
//          2001/04/05  Y.Taka      Add debug trace
//          2001/04/24  Y.Taka      Add semaphore max counter
//
//*************************************************************************

#include "Ros33.h"
#include "internal.h"

#define ROS33_VERSION 0x0300    // version3.0

/*** start bss section global data ***/

T_TSKCB*    g_pCurTsk;          // current task
T_HNDRCB*   g_pCurHndr;         // current handler
//UB          g_ubIntNestCnt;     // interrupt nesting 
//UB          g_ubSysStat;        // system status
//UB          g_blDelay;          // delayed dispatching
SYSTIME     g_sSysTime;         // system time

T_TIMEOUTTSK g_sTimeOutTsk;                // time out task list
T_READYQUEUE g_sReadyQueue[MAX_TSKPRI];    // ready queue
T_TIMEHNDR   g_sTimeHndr;                  // time waiting handler list
T_READYHNDR  g_sReadyHndr;                 // ready handler queue

T_MLBXCB    g_sMlbxcb[MLBX_NUM];// mail box control block
T_SMPHCB    g_sSmphcb[SMPH_NUM];// semaphre control block
T_FLGCB     g_sFlgcb[FLG_NUM];  // flag control block
T_MSGBUFCB  g_sMsgbufcb[MSGBUF_NUM]; // message buffer control block
T_TSKCB     g_sTskcb[TSK_NUM];  // task control block
T_MPLCB     g_sMplcb[MPLBLK_NUM];// variable-memory pool contorol block
T_MPLCB     g_sMpfcb[MPFBLK_NUM];// fixed-memory pool contorol block
T_HNDRCB    g_sCycHndrcb[CYCHNDR_NUM];// cyclic handler contorol block
T_HNDRCB    g_sAlmHndrcb[ALMHNDR_NUM];// alarm handler contorol block

/*02-6-19 15:52 Pessia:
 * we should be able to change g_uhIntTime , especially in Power Control */
UH    g_uhIntTime = INT_TIME;       // interrupt time

/*** end bss section global data ***/

//****************************************************************************
//***    List Control Library                                              ***
//****************************************************************************

//****************************************************************************
//  Delete member from list and Add member to before list
//****************************************************************************
void vfnDelAddMember
    (
    T_NODE* pList,      // add list
    T_NODE* pMember     // add member
    )
{
    (pMember->pPrv)->pNxt = pMember->pNxt;
    (pMember->pNxt)->pPrv = pMember->pPrv;

    pMember->pNxt = pList;
    pMember->pPrv = pList->pPrv;
    (pList->pPrv)->pNxt = pMember;
    pList->pPrv = pMember;
    
}

//****************************************************************************
//  Delete member from list and Initialize member
//****************************************************************************
void vfnDelInitMember
    (
    T_NODE* pMember    
    )
{
    (pMember->pPrv)->pNxt = pMember->pNxt;
    (pMember->pNxt)->pPrv = pMember->pPrv;

    mInitMember(pMember);
    
}

//****************************************************************************
//  Add member to Timer sorting list
//****************************************************************************
void vfnAddTimer
    (
    T_NODE* pMember     // add member
    )
{
    T_NODE*     pTskcb;
    T_TSKCB*    pTskcb2;
    T_TSKCB*    pTskcb3;

    pTskcb = ((T_NODE*)&g_sTimeOutTsk)->pNxt;
    pTskcb2 = (T_TSKCB*)((char*)pTskcb - 8);       // offset of TCB head
    pTskcb3 = (T_TSKCB*)((char*)pMember - 8);      // offset of TCB head

    while((pTskcb != (T_NODE*)&g_sTimeOutTsk)
      &&((pTskcb2->utime < pTskcb3->utime)
        || ((pTskcb2->utime == pTskcb3->utime)
          && (pTskcb2->ltime <= pTskcb3->ltime))))
    {
        pTskcb = pTskcb->pNxt;
        pTskcb2 = (T_TSKCB*)((char*)pTskcb - 8);
    }

    pMember->pNxt = pTskcb;
    pMember->pPrv = pTskcb->pPrv;
    (pTskcb->pPrv)->pNxt = pMember;
    pTskcb->pPrv = pMember;
}

//****************************************************************************
//  Add member to TimeHndr sorting list
//****************************************************************************
void vfnAddTimeHndr
    (
    T_NODE* pMember     // add member
    )
{
    T_NODE*       pHndrcb;
    T_HNDRCB*     pHndrcb2;
    T_HNDRCB*     pHndrcb3;

    pHndrcb = ((T_NODE*)&g_sTimeHndr)->pNxt;
    pHndrcb2 = (T_HNDRCB*)((char*)pHndrcb);       // offset of HNDR head
    pHndrcb3 = (T_HNDRCB*)((char*)pMember);       // offset of HNDR head

    while((pHndrcb != (T_NODE*)&g_sTimeHndr)
      &&((pHndrcb2->utime < pHndrcb3->utime)
        || ((pHndrcb2->utime == pHndrcb3->utime)
          && (pHndrcb2->ltime <= pHndrcb3->ltime))))
    {
        pHndrcb = pHndrcb->pNxt;
        pHndrcb2 = (T_HNDRCB*)((char*)pHndrcb);
    }

    pMember->pNxt = pHndrcb;
    pMember->pPrv = pHndrcb->pPrv;
    (pHndrcb->pPrv)->pNxt = pMember;
    pHndrcb->pPrv = pMember;
}

//****************************************************************************
//  Only initialize member 
//  defined for macro in internal.h
//****************************************************************************


//****************************************************************************
//***    3.8 System Management Functions                                   ***
//****************************************************************************

//********************************************************************
//  Get Version Information
//  [Parameters]
//      T_VER   *pk_ver Packet address representing Version Information
//  [Return Parameters]
//      ER      ercd    ErrorCode
//     -(pk_ver members)-
//      UH      maker   OS Maker
//      UH      id      Identification Number of the OS
//      UH      spver   ITRON or uITRON Specification Version Number
//      UH      prver   OS Product Version Number
//      UH      prno[4] Product Number (Product Management Information)
//      UH      cpu     CPU Information
//      UH      var     Variation Descriptor
//********************************************************************
ER  get_ver
    (
    T_VER   *pk_ver
    )
{
#ifdef DEBUG_TRACE
    asm("xcall ros_dbg_syscall_trace");
#endif

#ifndef NO_ERROR_CHECK
    if(pk_ver == 0)
    {
        return E_PAR;
    }
#endif

    pk_ver->maker = 0x0000;         // maker code none
    pk_ver->id = 0x0091;            // id
    pk_ver->spver = 0x5302;         // mITRON ver3.02
    pk_ver->prver = ROS33_VERSION;  // implement version
    pk_ver->prno[0] = 0x0000;       // not use
    pk_ver->prno[1] = 0x0000;       // not use
    pk_ver->prno[2] = 0x0000;       // not use
    pk_ver->prno[3] = 0x0000;       // not use
    pk_ver->cpu = 0x0000;           // cpu code none
    pk_ver->var = 0x8000;           // level S (standard level)

#ifndef NO_RETURN_VALUE
    return E_OK;
#endif
}

//****************************************************************************
//***    Implementation-dependent Functions                                ***
//****************************************************************************

//********************************************************************
//  Create Task
//  [Parameters]
//      ID  tskid   Task ID
//      FP  task    Task start address
//      PRI itskpri Initial task priority 
//      UW  istkadr Initial stak address
//  [Return Parameters]
//      ER      ercd    ErrorCode
//********************************************************************
ER vcre_tsk
    (
    ID  tskid,
    FP  task,
    PRI itskpri,
    UW  istkadr
    )
{
    T_TSKCB*    pTskcb;

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

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

    if(tskid > TSK_NUM)
    {
        return E_NOEXS;
    }

    if((itskpri < 1)
    || (itskpri > MAX_TSKPRI))
    {
        return E_PAR;
    }
#endif

    pTskcb = &g_sTskcb[tskid-1];

    pTskcb->fpPC = task;	//gfd
    pTskcb->bIniPriority = itskpri-1;
    pTskcb->uwIniSP = istkadr;
    pTskcb->ubStatus = TTS_DMT;

    pTskcb->utime = 0;
    pTskcb->ltime = 0;

    mInitMember((T_NODE*)pTskcb);
    mInitMember((T_NODE*)&(pTskcb->pNxtTmoTsk));

    //init_fscb( &pTskcb->fscb );//02-8-24 10:02
    
#ifndef NO_RETURN_VALUE
    return E_OK;
#endif
}
    
//********************************************************************
//  Enter Interrupt Handler
//  [Parameters]
//      none
//  [Return Parameters]
//      none
//********************************************************************
ER ent_int
    (
    )
{
	g_ubIntNestCnt++;
	g_ubSysStat |= TSS_INDP;   // TSS_INDP= 4
}

//********************************************************************
//  System Initialize
//  [Parameters]
//      none
//  [Return Parameters]
//      none
//********************************************************************
void sys_ini
    (
    )
{
    int i;

#ifdef DEBUG_TRACE
    init_ros_dbg_logging();
#endif

    // init system clock 
    g_sSysTime.utime = 0;
    g_sSysTime.ltime = 0;

    g_ubIntNestCnt = 0;
    g_blDelay = 0;          // delayed dispatching
    g_ubSysStat = 0;        // system status

    loc_cpu();
    
    // init timeout task 
    mInitMember((T_NODE*)&(g_sTimeOutTsk.pNxtTimeOutTsk));

    // init ready queue 
    for(i = 0; i < MAX_TSKPRI; i++)
    {
        mInitMember((T_NODE*)&g_sReadyQueue[i]);
    }

    // init time waiting handler list
    mInitMember((T_NODE*)&(g_sTimeHndr.pNxtTimeHndr));

    // init ready handler queue
    mInitMember((T_NODE*)&(g_sReadyHndr.pNxtReadyHndr));

    
    // init semaphore 
    for(i = 0; i < SMPH_NUM; i++){
        mInitMember((T_NODE*)&g_sSmphcb[i]);
        g_sSmphcb[i].ubSmphMax = SMPH_CNT;
        g_sSmphcb[i].ubSmphCnt = SMPH_CNT;
    }

    // init event flag 
    for(i = 0; i < FLG_NUM; i++){
        mInitMember((T_NODE*)&g_sFlgcb[i]);
        g_sFlgcb[i].uhFlgPtn = 0;
        g_sFlgcb[i].uhWaiPtn = 0;    // wait pattern 
        g_sFlgcb[i].bWaiMode = 0;    // wait flag mode 
    }

    // init mail box 
    for(i = 0; i < MLBX_NUM; i++){
        mInitMember((T_NODE*)&g_sMlbxcb[i]);
         g_sMlbxcb[i].count = 0;//pessia
        g_sMlbxcb[i].pMsg = 0;
    }

    // init message buffer 
    for(i = 0; i < MSGBUF_NUM; i++){
        mInitMember((T_NODE*)&(g_sMsgbufcb[i].pNxtTsk));
        mInitMember((T_NODE*)&(g_sMsgbufcb[i].pNxtSndTsk));
        g_sMsgbufcb[i].bufst = 0;