osshow.c

ucos on sa1200 from ixp1200 EB

/* osshow.c
 *
 *------------------------------------------------------------
 *                                                                      
 *                  I N T E L   P R O P R I E T A R Y                   
 *                                                                      
 *     COPYRIGHT (c)  1998-1999 BY  INTEL  CORPORATION.  ALL RIGHTS          
 *     RESERVED.   NO  PART  OF THIS PROGRAM  OR  PUBLICATION  MAY      
 *     BE  REPRODUCED,   TRANSMITTED,   TRANSCRIBED,   STORED  IN  A    
 *     RETRIEVAL SYSTEM, OR TRANSLATED INTO ANY LANGUAGE OR COMPUTER    
 *     LANGUAGE IN ANY FORM OR BY ANY MEANS, ELECTRONIC, MECHANICAL,    
 *     MAGNETIC,  OPTICAL,  CHEMICAL, MANUAL, OR OTHERWISE,  WITHOUT    
 *     THE PRIOR WRITTEN PERMISSION OF :                                
 *                                                                      
 *                        INTEL  CORPORATION                            
 *                                                                     
 *                     2200 MISSION COLLEGE BLVD                        
 *                                                                      
 *               SANTA  CLARA,  CALIFORNIA  95052-8119                  
 *                                                                      
 *------------------------------------------------------------
 * system: SA1200
 * subsystem: uCOS
 * author: Henry Qian 12/02/98
 * revisions:
 *
 */
#include <stdio.h>
#include "os.h"

#ifdef __cplusplus
extern "C" {
#endif

    void uCOS_ShowAllTasks(void);
    void uCOS_ShowAllTasks2(void);
    void uCOS_ShowTaskTCB(OS_TCB* tcb);
    void uCOS_ShowAllTaskDetail(void);
    void uCOS_ShowAllTaskDetail2(void);
    void uCOS_ShowTaskDetail(unsigned int tid);
    void uCOS_ShowTaskDetailByTCB(OS_TCB* tcb);
    void uCOS_ShowEvent(OS_EVENT* pevent);
    void uCOS_ShowReadyTaskList(void);
    void uCOS_ShowTaskWaitList( unsigned int taskGroup,
                                unsigned int* taskTable);

#ifdef __cplusplus
}
#endif

extern uint OSMapTbl[];
extern uint OSRdyGrp;
extern uint OSRdyTbl[];

/*
**  void uCOS_ShowAllTasks()
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowAllTasks(void)
{
    int tid;

    printf(" ---------------------------------------------------------------\n");
    printf(" -- tid status   top     stack   bottom  usage   event  tmo/eval\n");
    printf(" ---------------------------------------------------------------\n");

    for (tid = 0; tid < OS_MAX_TASKS; tid++)
        uCOS_ShowTaskTCB(OSTCBPrioTbl[tid]);

    printf(" ---------------------------------------------------------------\n");
    printf(" -- CtxSwCtr: %08X IdleCtr: %08X OSTimer: %08X\n",
        OSCtxSwCtr, OSIdleCtr, OSTime);
#if 0
    printf(" -- ShedLock: %08X\n", OSLockNesting);
    uCOS_ShowReadyTaskList();
#endif
}


/*
**  void uCOS_ShowAllTasks2(void)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowAllTasks2(void)
{
    OS_TCB* tcb = OSTCBList;

    printf(" ---------------------------------------------------------\n");
    printf(" -- tid status   top     stack   bottom    event  tmo/eval\n");
    printf(" ---------------------------------------------------------\n");

    while(tcb->OSTCBPrio < OS_LO_PRIO)
    {
        uCOS_ShowTaskTCB(tcb);
        tcb = tcb->OSTCBNext;
    }

    printf(" ---------------------------------------------------------\n");
    printf(" -- CtxSwCtr: %08X IdleCtr: %08X OSTimer: %08X\n",
        OSCtxSwCtr, OSIdleCtr, OSTime);
#if 0
    printf(" -- ShedLock: %08X\n", OSLockNesting);
#endif
}

/*
**  void uCOS_ShowTaskTCB(OS_TCB* tcb)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowTaskTCB(OS_TCB* tcb)
{
    unsigned int eventValue = 0;
    unsigned char* stkPtr;

    if (tcb != 0)
    {
        /* task id, same as task priority */
        if (tcb == OSTCBCur)
            printf(" -- %02X* ", tcb->OSTCBPrio);  /* current running task */
        else
            printf(" -- %02X  ", tcb->OSTCBPrio);

        /* task status */
        switch(tcb->OSTCBStat)
        {
            case OS_STAT_RDY:
                printf("ready ");   /* task ready to run */
                eventValue = 0;
                break;

            case OS_STAT_SEM:
                printf("sem   ");   /* wait for semaphore */
                if (tcb->OSTCBEventPtr != 0)
                    eventValue = (unsigned int)(tcb->OSTCBEventPtr->OSEventCnt);
                break;

            case OS_STAT_MBOX:
                printf("mbox  ");   /* wait for mailbox */
                if (tcb->OSTCBEventPtr != 0)
                {
                    /* This value has to be zero, otherwise we wouldn't wait here */
                    eventValue = (unsigned int)(tcb->OSTCBEventPtr->OSEventPtr);
                }
                break;

            case OS_STAT_Q:
                printf("queue ");   /* wait for queue message */
                if (tcb->OSTCBEventPtr != 0)
                {
                    /* This value has to be zero, otherwise we wouldn't wait here */
                    eventValue = (unsigned int)(tcb->OSTCBEventPtr->OSEventPtr);
                }
                break;

            case OS_STAT_SLEEP:
                printf("sleep ");   /* wait for queue message */
                eventValue = tcb->OSTCBDly;
                break;

            default:
                printf("error ");   /* error status */
                eventValue = 0;
                break;
        }

        /* top/current/bottom stack boundaries */
        printf( "%08X %08X %08X ",
                (int)(tcb->OSTCBStkTop),
                (int)(tcb->OSTCBStkPtr),
                (int)(tcb->OSTCBStkBottom));

        if (    (((int*)tcb->OSTCBStkBottom)[0] != MAGIC_WORD0) ||
                (((int*)tcb->OSTCBStkBottom)[1] != MAGIC_WORD1) ||
                (((int*)tcb->OSTCBStkBottom)[2] != MAGIC_WORD2) ||
                (((int*)tcb->OSTCBStkBottom)[3] != MAGIC_WORD3) ||
                ((int)(tcb->OSTCBStkPtr) < (int)(tcb->OSTCBStkTop)) ||
                ((int)(tcb->OSTCBStkPtr) > (int)(tcb->OSTCBStkBottom)))
        {
            printf("ovflw ");
        }
        else
        {
            /* check stack usage */
            for (   stkPtr = (unsigned char*)(tcb->OSTCBStkTop);
                    stkPtr < (unsigned char*)(tcb->OSTCBStkBottom);
                    stkPtr++)
            {
                if (*stkPtr != 0xee)
                {
                    printf("%3d%%  ",
                            (((int)tcb->OSTCBStkBottom - (int)stkPtr) * 100) /
                             ((int)tcb->OSTCBStkBottom - (int)tcb->OSTCBStkTop));
                    break;
                }
            }

            if (stkPtr >= (unsigned char*)(tcb->OSTCBStkBottom))
                printf("error ");
        }
        /* event */
        printf("%08X ", (int)(tcb->OSTCBEventPtr));

        /* task sleep time */
        printf("%08X", eventValue);

        /* task priority sanity check */
        if (    (tcb->OSTCBPrio < OS_MAX_TASKS) &&
                (tcb->OSTCBX == (tcb->OSTCBPrio & 0x07)) &&
                (tcb->OSTCBBitX == OSMapTbl[tcb->OSTCBPrio & 0x07]) &&
                (tcb->OSTCBY == tcb->OSTCBPrio >> 3) &&
                (tcb->OSTCBBitY == OSMapTbl[tcb->OSTCBPrio >> 3]))
            printf("\n"); /* no error */
        else
            printf(" -- error!\n");
    }
}


/*
**  void uCOS_ShowAllTaskDetail(void)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowAllTaskDetail(void)
{
    int tid;

    for (tid = 0; tid < OS_MAX_TASKS; tid++)
    {
        if (OSTCBPrioTbl[tid] != 0)
            uCOS_ShowTaskDetail(tid);
    }
}


/*
**  void uCOS_ShowAllTaskDetail2(void)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowAllTaskDetail2(void)
{
    OS_TCB* tcb = OSTCBList;

    while(tcb->OSTCBPrio < OS_LO_PRIO)
    {
        uCOS_ShowTaskDetailByTCB(tcb);
        tcb = tcb->OSTCBNext;
    }
}


/*
**  void uCOS_ShowTaskDetail(unsigned int tid)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowTaskDetail(unsigned int tid)
{
    if (tid >= OS_MAX_TASKS)
        printf(" -- error: task id\n");

    uCOS_ShowTaskDetailByTCB(OSTCBPrioTbl[tid]);
}


/*
**  void uCOS_ShowTaskDetailByTCB(OS_TCB* tcb)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowTaskDetailByTCB(OS_TCB* tcb)
{
    unsigned int* pStk;
	pStk = (unsigned int*)tcb->OSTCBStkPtr;

    if (tcb == OSTCBCur)
        printf(" -- task: %02X* ---------------------------------------------\n",
            tcb->OSTCBPrio);
    else
        printf(" -- task: %02X ----------------------------------------------\n",
            tcb->OSTCBPrio);

    printf(" -- r00: %08X r01: %08X r02: %08X r03: %08X\n",
        pStk[2], pStk[3], pStk[4], pStk[5]);
    printf(" -- r04: %08X r05: %08X r06: %08X r07: %08X\n",
        pStk[6], pStk[7], pStk[8], pStk[9]);
    printf(" -- r08: %08X r09: %08X r10: %08X r11: %08X\n",
        pStk[10], pStk[11], pStk[12], pStk[13]);
    printf(" -- r12: %08X cpsr:%08X spsr:%08X pc:  %08X\n",
        pStk[14], pStk[0], pStk[1], pStk[15]);

    /* event */
    if (tcb->OSTCBEventPtr)
    {
        printf(" ----------------------------------------------------------\n");
        uCOS_ShowEvent(tcb->OSTCBEventPtr);
    }
}


/*
**  void uCOS_ShowEvent(OS_EVENT* pevent)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowEvent(OS_EVENT* pevent)
{
    if (pevent == 0)
        return;

    printf(" -- event: %08X count: %08X addr: %08X\n",
        (int)pevent, pevent->OSEventCnt, (int)pevent->OSEventPtr);

    uCOS_ShowTaskWaitList(pevent->OSEventGrp, pevent->OSEventTbl);
}


/*
**  void uCOS_ShowReadyTaskList(void)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowReadyTaskList(void)
{
    uCOS_ShowTaskWaitList(OSRdyGrp, OSRdyTbl);
}


/*
**  void uCOS_ShowTaskWaitList( unsigned int taskGroup,
**                              unsigned int* taskTable)
**
**  DESCRIPTION
** 
**  RETURNS
**      None.
*/
void uCOS_ShowTaskWaitList( unsigned int taskGroup,
                            unsigned int* taskTable)
{
    unsigned int tid;

    printf(" -- Group: %02X Table: %02X %02X %02X %02X %02X %02X %02X %02X\n",
        taskGroup & 0xff,
        taskTable[7] & 0xff,
        taskTable[6] & 0xff,
        taskTable[5] & 0xff,
        taskTable[4] & 0xff, 
        taskTable[3] & 0xff,
        taskTable[2] & 0xff,
        taskTable[1] & 0xff,
        taskTable[0] & 0xff);

    printf(" -- tid: ");
    for (tid = 0; tid < OS_MAX_TASKS; tid++)
    {
        if ((taskGroup & OSMapTbl[tid >> 3]) &&
            (taskTable[tid >> 3] & OSMapTbl[tid & 0x07]))
        {
            printf(" %02X", tid);
        }
    }

    printf("\n");
}


/* end of file */