* 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 */