tmp.c

OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI的双核处理器

/*****************************************************************************
* LOCAL VARIABLES DECLARATIONS
******************************************************************************
*/

/*****************************************************************************
* LOCAL FUNCTIONS PROTOTYPES
******************************************************************************
*/

/*****************************************************************************
* FUNCTIONS
******************************************************************************
*/

void CAM1PowerOnResetTest(const UWORD32 baseAddress)
{
    UWORD32 i;
    UWORD32 regVal32;
    UWORD16 regVal16;
    UWORD8 regVal8;

    MSG_START_POR_TESTS;

    for( i = 0 ; i < CAM1_POR_REGISTERS ; i++ )
    {
        switch( CAM1PowerOnResetData[i].regType )
        {

        case ACC_32BIT:
        {
            regVal32 = RD_MEM_32_VOLATILE(CAM1PowerOnResetData[i].address + baseAddress);

            MSG_POR_TEST(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address);

            regVal32 &= CAM1PowerOnResetData[i].powerOnMask;

            // Check value of register

            if( regVal32 != (((CAM1PowerOnResetData[i].powerOnValue & CAM1PowerOnResetData[i].rsrvdReturnZerosMask) | CAM1PowerOnResetData[i].rsrvdReturnOnesMask) & CAM1PowerOnResetData[i].powerOnMask))
            {
                MSG_POR_FAIL(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address, regVal32);
            }

            break;
        }

        case ACC_16BIT:
        {
            regVal16 =  RD_MEM_16_VOLATILE(CAM1PowerOnResetData[i].address + baseAddress);

            MSG_POR_TEST(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address);

            regVal16 &= CAM1PowerOnResetData[i].powerOnMask;

            // Check value of register

            if( regVal16 != (((CAM1PowerOnResetData[i].powerOnValue & CAM1PowerOnResetData[i].rsrvdReturnZerosMask) | CAM1PowerOnResetData[i].rsrvdReturnOnesMask) & CAM1PowerOnResetData[i].powerOnMask))
            {
                MSG_POR_FAIL(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address, regVal16);
            }

            break;
        }

        case ACC_8BIT:
        {
            regVal8 =  RD_MEM_8_VOLATILE(CAM1PowerOnResetData[i].address + baseAddress);

            MSG_POR_TEST(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address);

            regVal8 &= CAM1PowerOnResetData[i].powerOnMask;

            // Check value of register

            if( regVal8 != (((CAM1PowerOnResetData[i].powerOnValue & CAM1PowerOnResetData[i].rsrvdReturnZerosMask) | CAM1PowerOnResetData[i].rsrvdReturnOnesMask) & CAM1PowerOnResetData[i].powerOnMask))
            {
                MSG_POR_FAIL(CAM1PowerOnResetData[i].regType, CAM1PowerOnResetData[i].address, regVal8);
            }

            break;
        }

        default:
        break;

        }
    }

    MSG_END_POR_TESTS;
}

void CAM1RegisterExclusivityTestUp(const UWORD32 baseAddress)
{
    UWORD32 i;
    UWORD32 regVal;
    registerExclusivityStruct r;
    
    UWORD32 ONES32;
    UWORD32 ZEROS32;
    
    UWORD16 ONES16;
    UWORD16 ZEROS16;
    
    UWORD8 ONES8;
    UWORD8 ZEROS8;

    MSG_START_RE_UP_TESTS;

    for( i = 0 ; i < CAM1_EXCLUSIVITY_REGISTERS ; i++ )
    {

        r =  CAM1RegisterExclusivityData[i];

        MSG_RE_UP_TEST_PART1(r.regType, r.address);
        
        ONES32 = (0xffffffff & r.includeMask) | (r.powerOnValue & ~r.includeMask); 
        ZEROS32 = r.powerOnValue & ~r.includeMask; 
        
        ONES16 = (0xffff & (UWORD16)r.includeMask) | ((UWORD16)r.powerOnValue & ~(UWORD16)r.includeMask); 
        ZEROS16 = (UWORD16)r.powerOnValue & ~(UWORD16)r.includeMask; 

        ONES8 = (0xff & (UWORD8)r.includeMask) | ((UWORD8)r.powerOnValue & ~(UWORD8)r.includeMask); 
        ZEROS8 = (UWORD8)r.powerOnValue & ~(UWORD8)r.includeMask; 
        
        switch( r.regType )
        {

        case ACC_32BIT:
        {
            if( (READ_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                regVal = RD_MEM_32_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_32_VOLATILE(r.address + baseAddress, ONES32);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_32_VOLATILE(r.address + baseAddress);

                if( (((ONES32 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }

        case ACC_16BIT:
        {            
            if( (READ_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                regVal = RD_MEM_16_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_16_VOLATILE(r.address + baseAddress, ONES16);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_16_VOLATILE(r.address + baseAddress);

                if( (((ONES16 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }

        case ACC_8BIT:
        {
            if( (READ_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                regVal = RD_MEM_8_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_8_VOLATILE(r.address + baseAddress, ONES8);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_8_VOLATILE(r.address + baseAddress);

                if( (((ONES8 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }

        default:
            break;
        }
    }

    for( i = 0 ; i < CAM1_EXCLUSIVITY_REGISTERS ; i++ )
    {

        r =  CAM1RegisterExclusivityData[i];

        MSG_RE_UP_TEST_PART2(r.regType, r.address);

        ONES32 = (0xffffffff & r.includeMask) | (r.powerOnValue & ~r.includeMask); 
        ZEROS32 = r.powerOnValue & ~r.includeMask; 
        
        ONES16 = (0xffff & (UWORD16)r.includeMask) | ((UWORD16)r.powerOnValue & ~(UWORD16)r.includeMask); 
        ZEROS16 = (UWORD16)r.powerOnValue & ~(UWORD16)r.includeMask; 

        ONES8 = (0xff & (UWORD8)r.includeMask) | ((UWORD8)r.powerOnValue & ~(UWORD8)r.includeMask); 
        ZEROS8 = (UWORD8)r.powerOnValue & ~(UWORD8)r.includeMask; 

        switch( r.regType )
        {

        case ACC_32BIT:
        {
            if( READ_ONLY == r.IOstatus ) 
            {
                regVal = RD_MEM_32_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }
            else if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_32_VOLATILE(r.address + baseAddress);

                if( (((ONES32 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_32_VOLATILE(r.address + baseAddress, ZEROS32);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_32_VOLATILE(r.address + baseAddress);

                if( ((ZEROS32 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ZEROS_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }

        case ACC_16BIT:
        {
            if( READ_ONLY == r.IOstatus ) 
            {
                regVal = RD_MEM_16_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }
            else if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_16_VOLATILE(r.address + baseAddress);

                if( (((ONES16 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_16_VOLATILE(r.address + baseAddress, ZEROS16);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_16_VOLATILE(r.address + baseAddress);

                if( ((ZEROS16 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ZEROS_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }

        case ACC_8BIT:
        {
            if( READ_ONLY == r.IOstatus ) 
            {
                regVal = RD_MEM_8_VOLATILE(r.address + baseAddress);

                if( (regVal & r.powerOnMask) != (((r.powerOnValue & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.powerOnMask))
                {
                    MSG_RE_UP_POWER_ON_FAIL(r.regType, r.address, regVal);
                }
            }
            else if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_8_VOLATILE(r.address + baseAddress);

                if( (((ONES8 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) & r.readMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ONES_FAIL(r.regType, r.address, regVal);
                }
            }

            if( (WRITE_ONLY == r.IOstatus) || (READ_WRITE == r.IOstatus) )
            {
                WR_MEM_8_VOLATILE(r.address + baseAddress, ZEROS8);
            }

            if( READ_WRITE == r.IOstatus )
            {
                regVal = RD_MEM_8_VOLATILE(r.address + baseAddress);

                if( ((ZEROS8 & r.rsrvdReturnZerosMask) | r.rsrvdReturnOnesMask) != (regVal & r.readMask) )
                {
                    MSG_RE_UP_ZEROS_FAIL(r.regType, r.address, regVal);
                }
            }
            break;
        }
        default:
            break;
        }
    }