xutil_memtest.c

关于xilinx大学计划培训教程3的实例代码

                 * initial value
                 */

                Val = ~(1 << j);

                /* Read the values from each location that was written */

                for (i = 0L; i < 16; i++)
                {

                    /* read memory location */

                    Word = Addr[i];

                    if (Word != Val)
                    {
                        return XST_MEMTEST_FAILED;
                    }

                    Val = ~((Xuint16) RotateLeft(~Val, 16));

                }

            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }

        } /* end of case 3 */

        /* fall through case statement */

        case XUT_INVERSEADDR:
        {

            /* Fill the memory with inverse of address */

            for (i = 0L; i < Words; i++)
            {
                /* write memory location */

                Val = (Xuint16) (~((Xuint32)(&Addr[i])));
                Addr[i] = Val;

            }

            /*
             * Check every word within the Words
             * of tested memory
             */

            for (i = 0L; i < Words; i++)
            {

                 /* read memory location */

                Word = Addr[i];

                Val = (Xuint16) (~((Xuint32)(&Addr[i])));

                if ((Word ^ Val) != 0x0000)
                {
                    return XST_MEMTEST_FAILED;
                }
            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }


        } /* end of case 4 */


        /* fall through case statement */

        case XUT_FIXEDPATTERN:
        {

            /*
             * Generate an initial value for
             * memory testing
             */

            if (Pattern == 0)
            {
                Val = 0xDEAD;

            }
            else
            {
                Val = Pattern;

            }

            /*
             * Fill the memory with fixed pattern
             */

            for (i = 0L; i < Words; i++)
            {

                /* write memory location */

                Addr[i] = Val;

            }

            /*
             * Check every word within the Words
             * of tested memory and compare it
             * with the fixed pattern
             */

            for (i = 0L; i < Words; i++)
            {

                /* read memory location */

                Word = Addr[i];

                if (Word != Val)
                {
                    return XST_MEMTEST_FAILED;
                }
            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }

        } /* end of case 5 */

        /* this break is for the prior fall through case statements */

        break ;

        default:
        {
            return XST_MEMTEST_FAILED;
        }

    }  /* end of switch */

    /* Successfully passed memory test ! */

    return XST_SUCCESS;
}


/*****************************************************************************/
/**
*
* Performs a destructive 8-bit wide memory test.
*
* @param    Addr is a pointer to the region of memory to be tested.
* @param    Words is the length of the block.
* @param    Pattern is the constant used for the constant pattern test, if 0,
*           0xDEADBEEF is used.
* @param    Subtest is the test selected. See xutil.h for possible values.
*
* @return
*
* - XST_MEMTEST_FAILED is returned for a failure
* - XST_SUCCESS is returned for a pass
*
* @note
*
* Used for spaces where the address range of the region is smaller than
* the data width. If the memory range is greater than 2 ** width,
* the patterns used in XUT_WALKONES and XUT_WALKZEROS will repeat on a
* boundry of a power of two making it more difficult to detect addressing
* errors. The XUT_INCREMENT and XUT_INVERSEADDR tests suffer the same
* problem. Ideally, if large blocks of memory are to be tested, break
* them up into smaller regions of memory to allow the test patterns used
* not to repeat over the region tested.
*
*****************************************************************************/
XStatus XUtil_MemoryTest8(Xuint8 *Addr,Xuint32 Words, Xuint8 Pattern,
                          Xuint8 Subtest)
{
    Xuint32 i;
    Xuint32 j;
    Xuint8 Val= XUT_MEMTEST_INIT_VALUE;
    Xuint8 FirstVal= XUT_MEMTEST_INIT_VALUE;
    Xuint8 Word;

    XASSERT_NONVOID(Words != 0);
    XASSERT_NONVOID(Subtest <= XUT_MAXTEST);

    /*
     * select the proper Subtest(s)
     */

    switch (Subtest)
    {

        case XUT_ALLMEMTESTS:

        /* this case executes all of the Subtests */

        /* fall through case statement */

        case XUT_INCREMENT:
        {

            /*
             * Fill the memory with incrementing
             * values starting from 'FirstVal'
             */
            for (i = 0L; i < Words; i++)
            {

                /* write memory location */

                Addr[i] = Val;
                Val++;
            }

            /*
             * Restore the reference 'Val' to the
             * initial value
             */

            Val = FirstVal;

            /*
             * Check every word within the Words
             * of tested memory and compare it
             * with the incrementing reference
             * Val
             */

            for (i = 0L; i < Words; i++)
            {

                /* read memory location */

                Word = Addr[i];

                if (Word != Val)
                {
                    return XST_MEMTEST_FAILED;
                }
                Val++;
            }


            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }


        } /* end of case 1 */

        /* fall through case statement */

        case XUT_WALKONES:
        {
            /*
             * set up to cycle through all possible initial
             * test Patterns for walking ones test
             */

            for (j = 0L; j < 8; j++)
            {
                /*
                 * Generate an initial value for walking ones test to test
                 * for bad data bits
                 */

                Val = 1 << j;

                /*
                 * START walking ones test
                 * Write a one to each data bit indifferent locations
                 */

                for (i = 0L; i < 8; i++)
                {

                    /* write memory location */

                    Addr[i] = Val;
                    Val = (Xuint8) RotateLeft(Val, 8);
                }

                /*
                 * Restore the reference 'Val' to the
                 * initial value
                 */
                Val = 1 << j;

                /* Read the values from each location that was written */

                for (i = 0L; i < 8; i++)
                {

                    /* read memory location */

                    Word = Addr[i];

                    if (Word != Val)
                    {
                        return XST_MEMTEST_FAILED;
                    }

                    Val = (Xuint8) RotateLeft(Val, 8);

                }

            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }


        } /* end of case 2 */

        /* fall through case statement */

        case XUT_WALKZEROS:
        {
            /*
             * set up to cycle through all possible initial test
             * Patterns for walking zeros test
             */

            for (j = 0L; j < 8; j++)
            {

                /*
                 * Generate an initial value for walking ones test to test
                 * for bad data bits
                 */

                Val = ~(1 << j);

                /*
                 * START walking zeros test
                 * Write a one to each data bit indifferent locations
                 */

                for (i = 0L; i < 8; i++)
                {


                    /* write memory location */

                    Addr[i] = Val;
                    Val = ~((Xuint8) RotateLeft(~Val, 8));

                }

                /*
                 * Restore the reference 'Val' to the
                 * initial value
                 */

                Val = ~(1 << j);

                /* Read the values from each location that was written */

                for (i = 0L; i < 8; i++)
                {

                    /* read memory location */

                    Word = Addr[i];

                    if (Word != Val)
                    {
                        return XST_MEMTEST_FAILED;
                    }

                    Val = ~((Xuint8) RotateLeft(~Val, 8));

                }

            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }

        } /* end of case 3 */

        /* fall through case statement */

        case XUT_INVERSEADDR:
        {

            /* Fill the memory with inverse of address */

            for (i = 0L; i < Words; i++)
            {

                /* write memory location */

                Val = (Xuint8) (~((Xuint32)(&Addr[i])));
                Addr[i] = Val;

            }

            /*
             * Check every word within the Words
             * of tested memory
             */

            for (i = 0L; i < Words; i++)
            {

                /* read memory location */

                Word = Addr[i];

                Val = (Xuint8) (~((Xuint32)(&Addr[i])));

                if ((Word ^ Val) != 0x00)
                {
                    return XST_MEMTEST_FAILED;
                }
            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }


        } /* end of case 4 */


        /* fall through case statement */

        case XUT_FIXEDPATTERN:
        {

            /*
             * Generate an initial value for
             * memory testing
             */

            if (Pattern == 0)
            {
                Val = 0xA5;

            }
            else
            {
                Val = Pattern;

            }

            /*
             * Fill the memory with fixed pattern
             */

            for (i = 0L; i < Words; i++)
            {

                /* write memory location */

                Addr[i] = Val;

            }

            /*
             * Check every word within the Words
             * of tested memory and compare it
             * with the fixed pattern
             */

            for (i = 0L; i < Words; i++)
            {

                /* read memory location */

                Word = Addr[i];

                if (Word != Val)
                {
                    return XST_MEMTEST_FAILED;
                }
            }

            if (Subtest != XUT_ALLMEMTESTS)
            {
                return XST_SUCCESS;
            }

        } /* end of case 5 */

        /* this break is for the prior fall through case statements */

        break ;

        default:
        {
            return XST_MEMTEST_FAILED;
        }

    }  /* end of switch */

    /* Successfully passed memory test ! */

    return XST_SUCCESS;
}


/*****************************************************************************/
/**
*
* Rotates the provided value to the left one bit position
*
* @param    Input is value to be rotated to the left
* @param    Width is the number of bits in the input data
*
* @return
*
* The resulting unsigned long value of the rotate left
*
* @note
*
* None.
*
*****************************************************************************/
static Xuint32 RotateLeft(Xuint32 Input, Xuint8 Width)
{
    Xuint32 Msb;
    Xuint32 ReturnVal;
    Xuint32 WidthMask;
    Xuint32 MsbMask;

    /*
     * set up the WidthMask and the MsbMask
     */

    MsbMask = 1 << (Width-1);

    WidthMask = (MsbMask << 1) - 1;

    /*
     * set the width of the Input to the correct width
     */

    Input = Input & WidthMask;

    Msb = Input & MsbMask;

    ReturnVal = Input << 1;

    if (Msb != 0x00000000)
    {
        ReturnVal = ReturnVal | 0x00000001;
    }

    ReturnVal = ReturnVal & WidthMask;

    return (ReturnVal);

}

#ifdef ROTATE_RIGHT
/*****************************************************************************/
/**
*
* Rotates the provided value to the right one bit position
*
* @param    Input is value to be rotated to the right
* @param    Width is the number of bits in the input data
*
* @return
*
* The resulting Xuint32 value of the rotate right
*
* @note
*
* None.
*
*****************************************************************************/
static Xuint32 RotateRight(Xuint32 Input, Xuint8 Width)
{
    Xuint32 Lsb;
    Xuint32 ReturnVal;
    Xuint32 WidthMask;
    Xuint32 MsbMask;

    /*
     * set up the WidthMask and the MsbMask
     */

    MsbMask = 1 << (Width-1);

    WidthMask = (MsbMask << 1) - 1;

    /*
     * set the width of the Input to the correct width
     */

    Input = Input & WidthMask;

    ReturnVal = Input >> 1;

    Lsb = Input & 0x00000001;

    if (Lsb != 0x00000000)
    {
        ReturnVal = ReturnVal | MsbMask;
    }

    ReturnVal = ReturnVal & WidthMask;

    return (ReturnVal);

}
#endif /* ROTATE_RIGHT */