bdwtests.c

开发Inetl IXP2400平台所必须的硬件诊断和测试程序。该软件包支持的功能包括CPU基本功能检测

BDW_Status_t 
CheckDefaultValues(bb_ChipData_t *pChipData)
{
    int i=0;
    bb_ChipSegment_t section;
    bb_RegPointer_type pReg;

    /* Assign channel number */
    section.group.channel = 0;

    /* Read and check the default values */
    while ((defaultArray[i].offset != (bb_RegPointer_type)0xFFFF) &&
        (defaultArray[i].value != IXF_INIT_DATA_DELIMITER))
    {
        /* Form the address */
        pReg = (pChipData->BaseAddress + (ulong) defaultArray[i].offset);

        if (READ_FROM_HW(pReg) != defaultArray[i].value)
        {
            eprintf("BA = %08x ", pChipData->BaseAddress);
            eprintf("MISMATCH on addr = %08x", pReg);
            eprintf(" EXPECTED=0x%04x", defaultArray[i].value);
            eprintf(" ACTUAL=0x%04x\n", READ_FROM_HW(pReg));

            return BDW_FAIL;
        }

        i++;
    }

    return BDW_SUCCESS;
}

/***********************************************************************
****                       PUBLIC ROUTINES                          ****
***********************************************************************/


/******************************************************************
* Function : BdwPRBSLoopbackTest
*-----------------------------------------------------------------
* Description  : This routine performs a media loopback test by
*                generating a PRBS test pattern and then analyzing
*                the pattern.
*-----------------------------------------------------------------
* Inputs  : pChipData : Valid chip handle pointer.
*           chanNum : Specifies the channel number.
*           mode : Specifies INTERNAL or EXTERNAL loopback
*           timeOut : Time in seconds to perform the test.
* Outputs : None.
*-----------------------------------------------------------------
* Returns : Status
*-----------------------------------------------------------------
* Access Globals : eduCommon structure
*-----------------------------------------------------------------
* Comments : None.
******************************************************************/
BDW_Status_t 
BdwPRBSLoopbackTest(bb_ChipData_t *pChipData, int chanNum,
    LoopBackMode_t mode, int timeOut)
{
    BDW_Status_t status;
    ushort regVal;
    ushort chipId;
    bb_ChipSegment_t section;

    /* Print Banner */
    eprintf("\n\nPerforming PRBS Test on:\nChannel# : %d\nLoopback : \
%s\nTimeout : %d secs\n\n",
        chanNum, (mode) ? "EXTERNAL" : "INTERNAL", timeOut);

    /* Assign channel number */
    section.group.channel = chanNum;

    eprintf("Resetting the device\n");
    /* Reset Device */
    IxfApiReset(pChipData, &section, bb_RESET_CHIP);

    eprintf("Checking default values\n");
    if (CheckDefaultValues(pChipData) == BDW_FAIL)
    {
        eprintf("FAILED Reset\n");
        return BDW_FAIL;
    }
    eprintf("Default values are good\n");

    /* Start Test */
    status = StartPRBSLoopbackTest(pChipData, chanNum, mode);

    if (status == BDW_SUCCESS)
    {
        /* Poll the PRBS interrupt to see if PRBS Test failed */
        while (timeOut)
        {
            eprintf("%d ", timeOut);

            /* Read the PRBS Interrupts */
            IxfApiGenericRead(pChipData, TWO_BYTES, PRBSINT, 1, &regVal);

            IxfApiGenericRead(pChipData, TWO_BYTES, CHIP_ID, 1, &chipId);

            /* Make sure we can read the chip id first */
            if (chipId != 0x0201)
            {
                eprintf("\nInvalid chipId %x\n", chipId);
                break;
            }

            /* Check to see if we got an interrupt on our channel */
            if (regVal & (1 << chanNum))
            {
                break;
            }

            /* Sleep for 1 second */
            OS_TASK_SLEEP(1);

            timeOut--;
        }

        eprintf("\n");

        /* Stop Timer */
        status = StopPRBSLoopbackTest(pChipData);
    }

    /* Check to see if we got an error during the test */
    if ((timeOut) || (status != BDW_SUCCESS))
    {
        status = BDW_PRBS_TESTED_ENDED_IN_ERROR;
    }

    /* Dump Results */
    DumpPRBSResults(status);

    return status;
}


/******************************************************************
* Function : BdwRegisterAccessTest
*-----------------------------------------------------------------
* Description  : This routine performs a read and write test on
*                device to make sure the basics are working.
*-----------------------------------------------------------------
* Inputs  : pChipData : Valid chip handle pointer.
* Outputs : None.
*-----------------------------------------------------------------
* Returns : Status
*-----------------------------------------------------------------
* Access Globals : eduCommon structure
*-----------------------------------------------------------------
* Comments : None.
******************************************************************/
BDW_Status_t 
BdwRegisterAccessTest(bb_ChipData_t *pChipData)
{
    bb_ChipSegment_t section;

    /* Assign channel number */
    section.group.channel = 0;

    eprintf("Resetting the device\n");
    /* Reset Device */
    IxfApiReset(pChipData, &section, bb_RESET_CHIP);

    eprintf("Checking default values\n");
    if (CheckDefaultValues(pChipData) == BDW_FAIL)
    {
        return BDW_FAIL;
    }
    eprintf("Default values are good\n");

    /********* Register Testing *******************/

    /* Write data */
    eprintf("Write 0xAAAA pattern\n");
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(MACNF)), 0xAAAA);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(GOCNF)), 0xAAAA);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(COCNF(0))), 0xAAAA);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(R_COCNF(0))), 0xAAAA);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(T_COCNF(0))), 0xAAAA);

    /* Read and Compare data */
    eprintf("Reading and Comparing data\n");
    if (
        ((ushort) IXF6048_REG_VAL(MACNF)         != (ushort)  0x2) ||
        ((ushort) IXF6048_REG_VAL(GOCNF)         != (ushort)  0xAAA) ||
        ((ushort) IXF6048_REG_VAL(COCNF(0))      != (ushort)  0x2A) ||
        ((ushort) IXF6048_REG_VAL(R_COCNF(0))    != (ushort)  0x2AA) ||
        ((ushort) IXF6048_REG_VAL(T_COCNF(0))    != (ushort)  0xAAA) 
        )
    {
        return BDW_FAIL;
    }

    /* Write data */
    eprintf("Write 0xFFFF pattern\n");
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(MACNF)), 0xFFFF);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(GOCNF)), 0xFFFF);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(COCNF(0))), 0xFFFF);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(R_COCNF(0))), 0xFFFF);
    WRITE_TO_HW((bb_RegPointer_type)(IXF6048_REG(T_COCNF(0))), 0xFFFF);

    /* Read and Compare data */
    eprintf("Reading and Comparing data\n");
    if (
        ((ushort) IXF6048_REG_VAL(MACNF)         != (ushort)  0x7) ||
        ((ushort) IXF6048_REG_VAL(GOCNF)         != (ushort)  0x3FFF) ||
        ((ushort) IXF6048_REG_VAL(COCNF(0))      != (ushort)  0x3F) ||
        ((ushort) IXF6048_REG_VAL(R_COCNF(0))    != (ushort)  0x3FF) ||
        ((ushort) IXF6048_REG_VAL(T_COCNF(0))    != (ushort)  0xFFF) 
        )
    {
        return BDW_FAIL;
    }

    return BDW_SUCCESS;
}

static void BdwUnit_Help(void)
{
	eprintf("> t unit <option> <channel> <iteration> <mode> <time>, where\n");
	eprintf("<option> are:\n");
	eprintf("r - Register read/write test\n");
	eprintf("l - PRBS loopback test\n");
	eprintf("h - LED help message\n");
}

/******************************************************************
* Function : BdwUnit_Test
*-----------------------------------------------------------------
* Description  : This routine calls the specific unit test given
*                the parsed command line instruction
*-----------------------------------------------------------------
* Inputs  : None.
* Outputs : None.
*-----------------------------------------------------------------
* Returns : None.
*-----------------------------------------------------------------
* Access Globals : eduCommon structure.
*-----------------------------------------------------------------
* Comments : None.
******************************************************************/
void
BdwUnit_Test(void)
{
    register eduCommon* acL = (eduCommon *) ACADDRESS;
    char opt;
    int i;
    int channel, mode, time, iterations = 1;
    BDW_Status_t status;
    bb_ChipData_t *pChipData = acL->chipId;

    opt = acL->dc.argv[2][0];
    channel = acL->dc.decArg[3];
    iterations = acL->dc.decArg[3];
    mode = acL->dc.decArg[4];
    time = acL->dc.decArg[5];

    switch(opt)
    {

    case 'r':
        for (i=0; i < iterations; i++)
        {
            eprintf("***************************\n");
            eprintf(" R/W Test Iteration #: %d\n", (i+1));
            eprintf("***************************\n");
            /* RegisterAccess Test */
            status = BdwRegisterAccessTest(pChipData);
            DumpRegAccessResults(status);
            if(KEYPRESS)
		    {
			    break;
		    }
        }
        break;

    case 'l':
        Set_LED("PRBS");
        /* PRBS Loopback Test */
        BdwPRBSLoopbackTest(pChipData, channel, mode, time);
        break;

    case 'h':
	default:
        BdwUnit_Help();
    }
}

/******************************************************************
* Function : BdwUnit_All
*-----------------------------------------------------------------
* Description  : This routine calls all specific unit test
*-----------------------------------------------------------------
* Inputs  : None.
* Outputs : None.
*-----------------------------------------------------------------
* Returns : None.
*-----------------------------------------------------------------
* Access Globals : eduCommon structure.
*-----------------------------------------------------------------
* Comments : None.
******************************************************************/
void
BdwUnit_All(void)
{
    int forever = 0, loops = 1;
    register eduCommon* acL = (eduCommon *) ACADDRESS;
    int channel, mode;
    BDW_Status_t status;
    bb_ChipData_t *pChipData = acL->chipId;
    int MaxNumOfChans;
    int failFlag = 0;

    if(acL->dc.argc < 3)
		forever = 0;
	else
	{
        loops = acL->dc.decArg[2];
        if(loops == 0)
            forever = 1;
        else
            forever = 0;
    }
    
    eprintf("**********************\n");
    eprintf("* Perforning RW TEST *\n");
    eprintf("**********************\n\n");
    while(loops-- || forever)
	{
        /* RegisterAccess Test */
        status = BdwRegisterAccessTest(pChipData);
        
        if (status != BDW_SUCCESS)
            failFlag = 1;
        
        DumpRegAccessResults(status);
        eprintf("\n\n");
        
        eprintf("************************\n");
        eprintf("* Perforning PRBS TEST *\n");
        eprintf("************************\n\n");
        
        /* Check to see if we are Battey Drew */
        if (!(strcmp(acL->i2cData.model_id, BATTETY_DREW_CARD)))
        {
            MaxNumOfChans  = 1;
        }
        /* Check to see if we are Battey Wallace */
        else if (!(strcmp(acL->i2cData.model_id, BATTETY_WALLACE_CARD)))
        {
            MaxNumOfChans = 4;
        }
        /* If not Drew or Wallace, then we are in trouble */
        else
        {
            eprintf("Unknown media card\n");
            return;
        }
        
        for (mode = INTERNAL; (mode <= EXTERNAL); mode++)
        {
            for (channel = 0; (channel < MaxNumOfChans); channel++)
            {
                /* PRBS Loopback Test */
                status = BdwPRBSLoopbackTest(pChipData, channel, mode, BDW_ALL_FIXED_TIME);
                
                if (status != BDW_SUCCESS)
                    failFlag = 1;
            }
            eprintf("\n\n");
        }
        
        /* Print the final results */
        if (failFlag)
        {
            eprintf("TEST FAIL!!!\n");
        }
        else
        {
            eprintf("ALL TEST PASS!!!\n");
        }
        if(KEYPRESS)
        {
            break;
        }
    }
}