dm_debug.c

pxa270触摸屏驱动程序

        DM_PrintSerial(buffer);
    }
#endif
} // DM_CwWarnPrintf ()


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

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

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

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

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

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

/*
*******************************************************************************
*******************************************************************************
    Command list based control and display of the debug switches,
      plus some menu support
*******************************************************************************
*******************************************************************************
*/

static
INT DM_CwTblAddrToIndex (PUINT32 controlWordArrayP)
{
    INT     i = 0;
    while ((DM_CwTblAddrAndNameList[i].addr)  && 
           ((PVOID)controlWordArrayP != DM_CwTblAddrAndNameList[i].addr))
    {
        i++;
    }
    return (i);
    
} // DM_CwTblAddrToIndex()

#if 0
// Save for possible future use with parameter input commands
static
INT DM_CwTblNameToIndex (PCHAR controlWordArrayNameP)
{
    INT     i = 0;
    while ((DM_CwTblAddrAndNameList[i].addr)  && 
           (strcmp (controlWordArrayNameP, DM_CwTblAddrAndNameList[i].parameterName)))
    {
        i++;
    }
    return (i);

} // DM_CwTblNameToIndex()
#endif


static
VOID DM_CwDisplayEnabledSwitches (INT cwArrayId)
{
    UINT i;
    CHAR msgBuf[60];
    sprintf (msgBuf, "Enabled Switches for %s:",
                    DM_CwTblAddrAndNameList[cwArrayId].outputName);
    DM_StartTest (msgBuf);

    for (i = 0;i < DM_CW_NUM_BITS_ASSIGNED ;i++ )
    {
        if (DM_ControlWordsGetBit (i, DM_CwTblAddrAndNameList[cwArrayId].addr))
        {
            printf ("   %s (#%3d)\r\n",DM_ControlWordsStrings[i],i);
        }
    }

    DM_CwDisplayCurrSwitchInfo(NULL,NULL);

    DM_FinishTest ("");
} // DM_CwDisplayEnabledSwitches ()


static
VOID DM_CwOperateSwitch (DM_ControlWordsBitsT bitId,
                         INT cwArrayId,
                         INT bitVal)
{
    PCHAR enableStrP;
    CHAR msgBuf[60];

    enableStrP = bitVal ? "Enabling": "Disabling";

    sprintf (msgBuf, "%s Switch for %s", enableStrP,
                     DM_CwTblAddrAndNameList[cwArrayId].outputName);
    DM_StartTest (msgBuf);

    DM_ControlWordsPutBit (bitId, bitVal, 
                           DM_CwTblAddrAndNameList[cwArrayId].addr);

    DM_CwDisplayCurrSwitchInfo(NULL,NULL);
    DM_FinishTest ("");
} // DM_CwOperateSwitch ()


VOID DM_CwDisplayCurrSwitchInfo (PVOID dummy1P, PCHAR dummy2P)
{
    printf ("\nCurr Switch = %d (%s).\r\n",
               DM_CwCurrentBitId, DM_ControlWordsStrings[DM_CwCurrentBitId]);

    printf ("States: %s, %d;\r\n",
                DM_CwTblAddrAndNameList[0].outputName,
                DM_ControlWordsGetBit (DM_CwCurrentBitId, 
                                    DM_CwTblAddrAndNameList[0].addr));
  
    printf ("  %s, %d; %s, %d\r\n",
                DM_CwTblAddrAndNameList[1].outputName,
                DM_ControlWordsGetBit (DM_CwCurrentBitId, 
                                    DM_CwTblAddrAndNameList[1].addr),
                DM_CwTblAddrAndNameList[2].outputName,
                DM_ControlWordsGetBit (DM_CwCurrentBitId, 
                                    DM_CwTblAddrAndNameList[2].addr));
  
} // DM_CwDisplayCurrSwitchInfo ()



VOID DM_CwNameControlWordBits (PVOID argP, PCHAR paramP)
{
    INT i;
    for (i = 0; i<DM_CW_NUM_BITS_ASSIGNED ;i++ )
    {
        printf ("ID # %d (%s)\r\n",
                           i, DM_ControlWordsStrings[i]);
        if (14 == i%15)  // Print only 15 at at time.
        {            // Don't stop twice for last ID.
            if (DM_CW_NUM_BITS_ASSIGNED-1 != i)
            {
                printf ("Press any key to continue\r\n");
                DM_GetKey();
            }
        }
    }
    // Don't let stop-test push info off the display, either.

    if ((14 != i%15)  // Case of 14 already covered
        && (10 < i%15))
    {
        printf ("Press any key to continue\r\n");
        DM_GetKey();
    }

    DM_CwDisplayCurrSwitchInfo(NULL,NULL);
    // Stop before finish-test, which steps on some of our output.
    if (DM_CW_NUM_BITS_ASSIGNED-1 != i)
    {
        printf ("Press any key to continue\r\n");
        DM_GetKey();
    }
    DM_FinishTest ("");

} // DM_CwNameControlWordBits ()


VOID DM_CwDisableAllControlWordBits (PVOID argP, PCHAR paramP)
{
    DM_StartTest ("");
    DM_ControlWordsClear ();
    DM_CwDisplayCurrSwitchInfo(NULL,NULL);
    DM_FinishTest ("Disabled All Dbg Ctrl Wd Switches");
    
} // DM_CwDisableAllControlWordBits ()

//@@@  Set/ResetTypeandBit ()
//@@@  Select bit ()

//VOID DM_CwSelectBit (PVOID argP, PCHAR paramP)
//{ Need to parse params to get  bit.
//    if (DM_CwCurrentBitId  <  (DM_CW_NUM_BITS_ASSIGNED -1))
//    {
//        DM_CwCurrentBitId++;
//    }
//} // DM_CwSelectNextBit  ()

/*
*******************************************************************************
    Menu-oriented commands to change the current control word bit ID.
*******************************************************************************
*/


VOID DM_CwSelectNextBit (PVOID argP, PCHAR paramP)
{
    if (DM_CwCurrentBitId  <  (DM_CW_NUM_BITS_ASSIGNED -1))
    {
        DM_CwCurrentBitId++;
    }
    DM_StartTest ("Incremented Curr Switch");
    DM_CwDisplayCurrSwitchInfo(NULL,NULL);
    DM_FinishTest ("");

} // DM_CwSelectNextBit  ()


VOID DM_CwSelectPrevBit (PVOID argP, PCHAR paramP)
{
    if (DM_CwCurrentBitId)
    {
        DM_CwCurrentBitId--;
    }
    DM_StartTest ("Decremented Curr Switch");
    DM_CwDisplayCurrSwitchInfo(NULL,NULL);
    DM_FinishTest ("");

} // DM_CwSelectPrevBit  ()


VOID DM_CwDebugPrintfCtrlShow (PVOID arg, PCHAR paramP)
{
     DM_CwDisplayEnabledSwitches (
                         DM_CwTblAddrToIndex (&DM_ControlWordsDebugPrint[0]));

} // DM_CwDebugPrintfCtrlShow()


VOID DM_CwWarnPrintfCtrlShow (PVOID arg, PCHAR paramP)
{
     DM_CwDisplayEnabledSwitches (
                         DM_CwTblAddrToIndex (&DM_ControlWordsWarnPrint[0]));

} // DM_CwWarnPrintfCtrlShow()


VOID DM_CwErrPrintfCtrlShow (PVOID arg, PCHAR paramP)
{
     DM_CwDisplayEnabledSwitches (
                         DM_CwTblAddrToIndex (&DM_ControlWordsErrPrint[0]));

} // DM_CwErrPrintfCtrlShow()

/*
*******************************************************************************
    Toggle Current Bit (one for each type)
*******************************************************************************
*/

VOID DM_CwDebugPrintfCtrlToggle (PVOID arg, PCHAR paramP)
{
     DM_CwOperateSwitch (DM_CwCurrentBitId,
                         DM_CwTblAddrToIndex (&DM_ControlWordsDebugPrint[0]),
                         DM_ControlWordsGetBit(DM_CwCurrentBitId,
                            &DM_ControlWordsDebugPrint[0])^1);
    
} // DM_CwDebugPrintfCtrlToggle()


VOID DM_CwWarnPrintfCtrlToggle (PVOID arg, PCHAR paramP)
{
     DM_CwOperateSwitch (DM_CwCurrentBitId,
                         DM_CwTblAddrToIndex (&DM_ControlWordsWarnPrint[0]),
                         DM_ControlWordsGetBit(DM_CwCurrentBitId,
                            &DM_ControlWordsWarnPrint[0])^1);
    
} // DM_CwWarnPrintfCtrlToggle()


VOID DM_CwErrPrintfCtrlToggle (PVOID arg, PCHAR paramP)
{
     DM_CwOperateSwitch (DM_CwCurrentBitId,
                         DM_CwTblAddrToIndex (&DM_ControlWordsErrPrint[0]),
                         DM_ControlWordsGetBit(DM_CwCurrentBitId,
                            &DM_ControlWordsErrPrint[0])^1);
    
} // DM_CwErrPrintfCtrlToggle()

VOID DumpRegistersDbg (PUINT32 regP, INT numReg)
{
    UINT i;
    CHAR buffer[256];

    for (i = 0; i < numReg; i++)
    {
        sprintf (buffer, "Register  %08X %08X \r\n", (UINT)regP, *regP);
        regP++;
        printf(buffer);
    }
}