dm_debug.c

优龙YLP270开发板 光盘自带的BIOS和实验例程源码 强烈推荐

#define _DEFINING_DM_DEBUG

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "systypes.h"
#include "stubs.h"
#include "stdinout.h"
#define DEFINING_DM_DEBUG
#include "DM_Debug.h"


// Function prototype from dm.c: should move into dm.h, but this requires
//  too many files to #include <stdarg.h> for immediate usage.

//void doPrint(char * buffer, char * fmt, va_list ap);


/*
*******************************************************************************
    local definitions plus static variables and function prototypes.
*******************************************************************************
*/

typedef struct SysAddrStrTransTblEntryS
{
    PVOID addr;
    PCHAR parameterName;
    PCHAR outputName;

} SysAddrStrTransTblEntryT;

static
SysAddrStrTransTblEntryT DM_CwTblAddrAndNameList[]=
{
    {&DM_ControlWordsDebugPrint[0], "DEBUG PRINT",   "Debug Print"},
    {&DM_ControlWordsWarnPrint[0],  "WARNING PRINT", "Warning Print"},
    {&DM_ControlWordsErrPrint[0],   "ERROR PRINT",   "Error Print"},
    {NULL, "UNKNOWN",  "Unknown" },
} ;

static
INT  DM_CwCurrentBitId =  0;

static
INT DM_ControlWordsGetBit (DM_ControlWordsBitsT, PUINT32);

static
void DM_ControlWordsPutBit (DM_ControlWordsBitsT, INT, PUINT32);

static
INT DM_CwTblAddrToIndex (PUINT32 controlWordArrayP);
static
VOID DM_CwDisplayEnabledSwitches (INT cwArrayId);
static
VOID DM_CwOperateSwitch (DM_ControlWordsBitsT bitId,
                         INT cwArrayId,
                         INT bitVal);


/*
*******************************************************************************
    Put our own (non-optimized) version of memset() here because of
    the compiler bug in the official memset() some optimized code.
    Note: The need for this user-implemented function can be removed by
          installing compiler patch 723 for ADS 1.1, which is available from
          ARM, Ltd.  It fixes the memset() problem and some others.
*******************************************************************************
*/


void *MyMemset(void * s, int c, size_t n)
{
    PUINT8 fillP = (PUINT8) s;
    UINT8 fillChar = (UINT8) (c & 0xff);

    while (n--)
    {
        *fillP++ = fillChar;
    }
    return(s);
    
} // MyMemset()


/*
*******************************************************************************
    Replacement printf to redirect to our current display.
*******************************************************************************
*/
void doPrint(char * buffer, char * fmt, va_list ap)
{
    void *p1, *p2, *p3, *p4, *p5, *p6, *p7, *p8, *p9, *p10, *p11, *p12;

    p1 = va_arg(ap,void*);
    p2 = va_arg(ap,void*);
    p3 = va_arg(ap,void*);
    p4 = va_arg(ap,void*);

    p5 = va_arg(ap,void*);
    p6 = va_arg(ap,void*);
    p7 = va_arg(ap,void*);
    p8 = va_arg(ap,void*);

    p9 = va_arg(ap,void*);
    p10 = va_arg(ap,void*);
    p11 = va_arg(ap,void*);
    p12 = va_arg(ap,void*);

    sprintf(buffer,fmt,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12);
}

/*
*******************************************************************************
    These functions are probably more useful for the command line interface
    than the menu interface.
*******************************************************************************
*/

void DM_ControlWordsClear (void)
{
    MyMemset ((char *)&DM_ControlWordsDebugPrint[0], 0, sizeof (DM_ControlWordsDebugPrint));
    MyMemset ((char *)&DM_ControlWordsWarnPrint[0], 0, sizeof (DM_ControlWordsWarnPrint));
    MyMemset ((char *)&DM_ControlWordsErrPrint[0], 0, sizeof (DM_ControlWordsErrPrint));

} // DM_ControlWordsClear ()

void DM_ControlWordsCalcIndices (DM_ControlWordsBitsT bitId, PINT wordIndexP, PINT bitShiftP)
{
    *wordIndexP = (INT) bitId / DM_CONTROL_WORD_SIZE;
    *bitShiftP  = (INT) bitId & (DM_CONTROL_WORD_SIZE-1);

} // End DM_ControlWordsCalcIndices ()    


INT DM_ControlWordsDebugPrintGetBit (DM_ControlWordsBitsT bitId)
{
    return (DM_ControlWordsGetBit (bitId, 
                                        &DM_ControlWordsDebugPrint[0]));
} // DM_ControlWordsDebugPrintGetBit()

    
void DM_ControlWordsDebugPrintPutBit (DM_ControlWordsBitsT bitId, INT bitVal)
{   
    DM_ControlWordsPutBit (bitId, bitVal, &DM_ControlWordsDebugPrint[0]);

} // DM_ControlWordsDebugPrintPutBit ()


INT DM_ControlWordsWarnPrintGetBit (DM_ControlWordsBitsT bitId)
{
    return (DM_ControlWordsGetBit (bitId, 
                                        &DM_ControlWordsWarnPrint[0]));
} // DM_ControlWordsWarnPrintGetBit()


void DM_ControlWordsWarnPrintPutBit (DM_ControlWordsBitsT bitId, INT bitVal)
{
    DM_ControlWordsPutBit (bitId, bitVal, &DM_ControlWordsWarnPrint[0]);

} // DM_ControlWordsWarnPrintPutBit ()

INT DM_ControlWordsErrPrintGetBit (DM_ControlWordsBitsT bitId)
{
    return (DM_ControlWordsGetBit (bitId, 
                                        &DM_ControlWordsErrPrint[0]));

} // DM_ControlWordsErrPrintGetBit ()

void DM_ControlWordsErrPrintPutBit (DM_ControlWordsBitsT bitId, INT bitVal)
{
    DM_ControlWordsPutBit (bitId, bitVal, &DM_ControlWordsErrPrint[0]);

} // DM_ControlWordsErrPrintPutBit ()


/*
*******************************************************************************
    Generic functions for put and get control word bits
*******************************************************************************
*/

static
INT DM_ControlWordsGetBit (DM_ControlWordsBitsT bitId, 
                                PUINT32 controlWordsTableP)
{
    INT bitVal = 0;  // Illegal bits are disabled.
    INT wordIndex;
    INT bitShift;
    UINT32 controlWordTmp;

    if (bitId < DM_CW_NUM_BITS_ASSIGNED)
    {
        DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
        controlWordTmp = controlWordsTableP[wordIndex];
        // Normalize and report only the requested bit.  It may be used
        //  to restore setting later.
        bitVal = (controlWordTmp >> bitShift) &  1; 
    }
    return (bitVal);
    
} // DM_ControlWordsGetBit()

    
static
void DM_ControlWordsPutBit (DM_ControlWordsBitsT bitId, 
                                 INT bitVal, 
                                 PUINT32 controlWordsTableP)
{
    INT wordIndex;
    INT bitShift;
    UINT32 controlWordTmp;

    bitVal &= 1;    // Just one bit's worth, please.

    if (bitId < DM_CW_NUM_BITS_ASSIGNED)
    {
        DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
        controlWordTmp = controlWordsTableP[wordIndex] & ~(1u << bitShift);
        controlWordsTableP[wordIndex] = controlWordTmp | (bitVal << bitShift);
    }

/*
    printf ("PutBit: Base = %08x\r\n",
        (UINT)controlWordsTableP);
    printf ("Word Index = %d; Bit = %d\r\n",
        wordIndex, bitShift);
*/
} // DM_ControlWordsPutBit ()


/*
*******************************************************************************
    Conditional display based on any one control bit ID
*******************************************************************************
*/

void DM_CwDbgPrintf (DM_ControlWordsBitsT bitId, char * fmt, ...)
{
    INT wordIndex;
    INT bitShift;
    char buffer[256];
    va_list ap;

    DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
    if (DM_ControlWordsDebugPrint[wordIndex] & (1u << bitShift))
    {
        va_start(ap,fmt);
        doPrint(buffer,fmt,ap);
        printf(buffer);
        printf("\r\n");
    }
} // DM_CwDbgPrintf()

/*
*******************************************************************************
    Conditional display to serial device based on any one control bit ID
*******************************************************************************
*/

void DM_CwDbgSerialPrintf (DM_ControlWordsBitsT bitId, char * fmt, ...)
{
#ifdef temp
    INT wordIndex;
    INT bitShift;
    char buffer[256];
    va_list ap;

    DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
    if (DM_ControlWordsDebugPrint[wordIndex] & (1u << bitShift))
    {
        va_start(ap,fmt);
        doPrint(buffer,fmt,ap);
        DM_PrintSerial(buffer);
    }
#endif
} // DM_CwDbgPrintf()


/*
*******************************************************************************
    Warning display based on any one control bit ID
*******************************************************************************
*/

void DM_CwWarnPrintf (DM_ControlWordsBitsT bitId, char * fmt, ...)
{
#ifdef temp
    INT wordIndex;
    INT bitShift;
    char buffer[256];
    va_list ap;

    DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
    if (DM_ControlWordsWarnPrint[wordIndex] & (1u << bitShift))
    {
        va_start(ap,fmt);
        doPrint(buffer,fmt,ap);
        DM_Warning(buffer);
    }
#endif
} // DM_CwWarnPrintf ()


/*
*******************************************************************************
    Warning display to serial device based on any one control bit ID
*******************************************************************************
*/

void DM_CwWarnSerialPrintf (DM_ControlWordsBitsT bitId, char * fmt, ...)
{
#ifdef temp
    INT wordIndex;
    INT bitShift;
    char buffer[256];
    va_list ap;

    DM_ControlWordsCalcIndices(bitId, &wordIndex, &bitShift);
    if (DM_ControlWordsWarnPrint[wordIndex] & (1u << bitShift))
    {
        va_start(ap,fmt);
        doPrint(buffer,fmt,ap);