]> git.sur5r.net Git - u-boot/commitdiff
Remove the duplicate memory test code for mpc744ihpc2 board.
authorroy zang <tie-fei.zang@freescale.com>
Mon, 4 Dec 2006 06:33:08 +0000 (14:33 +0800)
committerZang Tiefei <roy@bus.ap.freescale.net>
Mon, 4 Dec 2006 06:33:08 +0000 (14:33 +0800)
If a memory test is needed, please use the functions in
post/memory.c or memtest command.
Signed-off-by: Roy Zang <tie-fei.zang@freescale.com>
board/mpc7448hpc2/mpc7448hpc2.c
include/configs/mpc7448hpc2.h

index 4d221e7a6973c050ffc0f7ea44cc1e4825c69fe2..d4a047c1d6faaa5a1db40a8059c48ede3cc9833c 100644 (file)
@@ -89,384 +89,6 @@ long int initdram (int board_type)
        return dram_size (board_type);
 }
 
-/* DRAM check routines copied from gw8260 */
-
-#if defined (CFG_DRAM_TEST)
-
-/*********************************************************************/
-/* NAME:  move64() -  moves a double word (64-bit)                  */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   this function performs a double word move from the data at             */
-/*   the source pointer to the location at the destination pointer.  */
-/*                                                                  */
-/* INPUTS:                                                          */
-/*   unsigned long long *src  - pointer to data to move                     */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   unsigned long long *dest - pointer to locate to move data      */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   None                                                           */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*   May cloober fr0.                                               */
-/*                                                                  */
-/*********************************************************************/
-static void move64 (unsigned long long *src, unsigned long long *dest)
-{
-       asm ("lfd  0, 0(3)\n\t" /* fpr0   =  *scr */
-               "stfd 0, 0(4)"  /* *dest  =  fpr0 */
-               : : :"fr0");    /* Clobbers fr0   */
-       return;
-}
-
-#if defined (CFG_DRAM_TEST_DATA)
-
-unsigned long long pattern[] = {
-       0xaaaaaaaaaaaaaaaaULL,
-       0xccccccccccccccccULL,
-       0xf0f0f0f0f0f0f0f0ULL,
-       0xff00ff00ff00ff00ULL,
-       0xffff0000ffff0000ULL,
-       0xffffffff00000000ULL,
-       0x00000000ffffffffULL,
-       0x0000ffff0000ffffULL,
-       0x00ff00ff00ff00ffULL,
-       0x0f0f0f0f0f0f0f0fULL,
-       0x3333333333333333ULL,
-       0x5555555555555555ULL
-};
-
-/*********************************************************************/
-/* NAME:  mem_test_data() -  test data lines for shorts and opens    */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   Tests data lines for shorts and opens by forcing adjacent data  */
-/*   to opposite states. Because the data lines could be routed in   */
-/*   an arbitrary manner the must ensure test patterns ensure that   */
-/*   every case is tested. By using the following series of binary   */
-/*   patterns every combination of adjacent bits is test regardless  */
-/*   of routing.                                                    */
-/*                                                                  */
-/*     ...101010101010101010101010                                  */
-/*     ...110011001100110011001100                                  */
-/*     ...111100001111000011110000                                  */
-/*     ...111111110000000011111111                                  */
-/*                                                                  */
-/*   Carrying this out, gives us six hex patterns as follows:       */
-/*                                                                  */
-/*     0xaaaaaaaaaaaaaaaa                                           */
-/*     0xcccccccccccccccc                                           */
-/*     0xf0f0f0f0f0f0f0f0                                           */
-/*     0xff00ff00ff00ff00                                           */
-/*     0xffff0000ffff0000                                           */
-/*     0xffffffff00000000                                           */
-/*                                                                  */
-/*   The number test patterns will always be given by:              */
-/*                                                                  */
-/*   log(base 2)(number data bits) = log2 (64) = 6                  */
-/*                                                                  */
-/*   To test for short and opens to other signals on our boards. we  */
-/*   simply                                                         */
-/*   test with the 1's complemnt of the paterns as well.            */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   Displays failing test pattern                                  */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   0 -  Passed test                                               */
-/*   1 -  Failed test                                               */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*  Assumes only one one SDRAM bank                                 */
-/*                                                                  */
-/*********************************************************************/
-int mem_test_data (void)
-{
-       unsigned long long *pmem = (unsigned long long *)CFG_MEMTEST_START;
-       unsigned long long temp64;
-       int num_patterns = sizeof (pattern) / sizeof (pattern[0]);
-       int i;
-       unsigned int hi, lo;
-
-       for (i = 0; i < num_patterns; i++) {
-               move64 (&(pattern[i]), pmem);
-               move64 (pmem, &temp64);
-
-               /* hi = (temp64>>32) & 0xffffffff; */
-               /* lo = temp64 & 0xffffffff;       */
-               /* printf ("\ntemp64 = 0x%08x%08x", hi, lo); */
-
-               hi = (pattern[i] >> 32) & 0xffffffff;
-               lo = pattern[i] & 0xffffffff;
-               /* printf ("\npattern[%d] = 0x%08x%08x", i, hi, lo);  */
-
-               if (temp64 != pattern[i]) {
-                       printf ("\n   Data Test Failed, pattern 0x%08x%08x",
-                              hi, lo);
-                       return 1;
-               }
-       }
-
-       return 0;
-}
-#endif /* CFG_DRAM_TEST_DATA */
-
-#if defined (CFG_DRAM_TEST_ADDRESS)
-/*********************************************************************/
-/* NAME:  mem_test_address() - test address lines                   */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   This function performs a test to verify that each word im      */
-/*   memory is uniquly addressable. The test sequence is as follows: */
-/*                                                                  */
-/*   1) write the address of each word to each word.                */
-/*   2) verify that each location equals its address                */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   Displays failing test pattern and address                      */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   0 -  Passed test                                               */
-/*   1 -  Failed test                                               */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*                                                                  */
-/*                                                                  */
-/*********************************************************************/
-int mem_test_address (void)
-{
-       volatile unsigned int *pmem =
-           (volatile unsigned int *)CFG_MEMTEST_START;
-       const unsigned int size = (CFG_MEMTEST_END - CFG_MEMTEST_START) / 4;
-       unsigned int i;
-
-       /* write address to each location */
-       for (i = 0; i < size; i++) {
-               pmem[i] = i;
-       }
-
-       /* verify each loaction */
-       for (i = 0; i < size; i++) {
-               if (pmem[i] != i) {
-                       printf ("\n   Address Test Failed at 0x%x", i);
-                       return 1;
-               }
-       }
-       return 0;
-}
-#endif /* CFG_DRAM_TEST_ADDRESS */
-
-#if defined (CFG_DRAM_TEST_WALK)
-/*********************************************************************/
-/* NAME:   mem_march() -  memory march                              */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   Marches up through memory. At each location verifies rmask if   */
-/*   read = 1. At each location write wmask if write = 1. Displays  */
-/*   failing address and pattern.                                   */
-/*                                                                  */
-/* INPUTS:                                                          */
-/*   volatile unsigned long long * base - start address of test             */
-/*   unsigned int size - number of dwords(64-bit) to test           */
-/*   unsigned long long rmask - read verify mask                    */
-/*   unsigned long long wmask - wrtie verify mask                   */
-/*   short read - verifies rmask if read = 1                        */
-/*   short write  - writes wmask if write = 1                       */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   Displays failing test pattern and address                      */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   0 -  Passed test                                               */
-/*   1 -  Failed test                                               */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*                                                                  */
-/*                                                                  */
-/*********************************************************************/
-int mem_march (volatile unsigned long long *base,
-             unsigned int size,
-             unsigned long long rmask,
-             unsigned long long wmask, short read, short write)
-{
-       unsigned int i;
-       unsigned long long temp;
-       unsigned int hitemp, lotemp, himask, lomask;
-
-       for (i = 0; i < size; i++) {
-               if (read != 0) {
-                       /* temp = base[i]; */
-                       move64 ((unsigned long long *)&(base[i]), &temp);
-                       if (rmask != temp) {
-                               hitemp = (temp >> 32) & 0xffffffff;
-                               lotemp = temp & 0xffffffff;
-                               himask = (rmask >> 32) & 0xffffffff;
-                               lomask = rmask & 0xffffffff;
-
-                               printf ("\n Walking one's test failed:  \
-                                       address = 0x%08x," "\n\texpected \
-                                       0x%08x%08x, found 0x%08x%08x", i << 3,\
-                                       himask, lomask, hitemp, lotemp);
-                               return 1;
-                       }
-               }
-               if (write != 0) {
-                       /*  base[i] = wmask; */
-                       move64 (&wmask, (unsigned long long *)&(base[i]));
-               }
-       }
-       return 0;
-}
-#endif /* CFG_DRAM_TEST_WALK */
-
-/*********************************************************************/
-/* NAME:   mem_test_walk() -  a simple walking ones test            */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   Performs a walking ones through entire physical memory. The     */
-/*   test uses as series of memory marches, mem_march(), to verify   */
-/*   and write the test patterns to memory. The test sequence is as  */
-/*   follows:                                                       */
-/*     1) march writing 0000...0001                                 */
-/*     2) march verifying 0000...0001  , writing  0000...0010       */
-/*     3) repeat step 2 shifting masks left 1 bit each time unitl    */
-/*        the write mask equals 1000...0000                         */
-/*     4) march verifying 1000...0000                               */
-/*   The test fails if any of the memory marches return a failure.   */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   Displays which pass on the memory test is executing            */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   0 -  Passed test                                               */
-/*   1 -  Failed test                                               */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*                                                                  */
-/*                                                                  */
-/*********************************************************************/
-int mem_test_walk (void)
-{
-       unsigned long long mask;
-       volatile unsigned long long *pmem =
-           (volatile unsigned long long *)CFG_MEMTEST_START;
-       const unsigned long size = (CFG_MEMTEST_END - CFG_MEMTEST_START) / 8;
-
-       unsigned int i;
-
-       mask = 0x01;
-
-       printf ("Initial Pass");
-       mem_march (pmem, size, 0x0, 0x1, 0, 1);
-
-       printf ("\b\b\b\b\b\b\b\b\b\b\b\b");
-       printf ("               ");
-       printf ("         ");
-       printf ("\b\b\b\b\b\b\b\b\b\b\b\b");
-
-       for (i = 0; i < 63; i++) {
-               printf ("Pass %2d", i + 2);
-               if (mem_march(pmem, size, mask, mask << 1, 1, 1) != 0)
-                       /*printf ("mask: 0x%x, pass: %d, ", mask, i); */
-                       return 1;
-               mask = mask << 1;
-               printf ("\b\b\b\b\b\b\b");
-       }
-
-       printf ("Last Pass");
-       if (mem_march(pmem, size, 0, mask, 0, 1) != 0) {
-               /* printf ("mask: 0x%x", mask); */
-               return 1;
-       }
-       printf ("\b\b\b\b\b\b\b\b\b");
-       printf ("            ");
-       printf ("\b\b\b\b\b\b\b\b\b");
-
-       return 0;
-}
-
-/*********************************************************************/
-/* NAME:    testdram() -  calls any enabled memory tests            */
-/*                                                                  */
-/* DESCRIPTION:                                                             */
-/*   Runs memory tests if the environment test variables are set to  */
-/*   'y'.                                                           */
-/*                                                                  */
-/* INPUTS:                                                          */
-/*   testdramdata    - If set to 'y', data test is run.                     */
-/*   testdramaddress - If set to 'y', address test is run.          */
-/*   testdramwalk    - If set to 'y', walking ones test is run      */
-/*                                                                  */
-/* OUTPUTS:                                                         */
-/*   None                                                           */
-/*                                                                  */
-/* RETURNS:                                                         */
-/*   0 -  Passed test                                               */
-/*   1 -  Failed test                                               */
-/*                                                                  */
-/* RESTRICTIONS/LIMITATIONS:                                        */
-/*                                                                  */
-/*                                                                  */
-/*********************************************************************/
-int testdram (void)
-{
-       char *s;
-       int rundata, runaddress, runwalk;
-
-       s = getenv ("testdramdata");
-       rundata = (s && (*s == 'y')) ? 1 : 0;
-       s = getenv ("testdramaddress");
-       runaddress = (s && (*s == 'y')) ? 1 : 0;
-       s = getenv ("testdramwalk");
-       runwalk = (s && (*s == 'y')) ? 1 : 0;
-
-/*    rundata = 1; */
-/*    runaddress = 0; */
-/*    runwalk = 0; */
-
-       if ((rundata == 1) || (runaddress == 1) || (runwalk == 1))
-               printf ("Testing RAM from 0x%08x to 0x%08x ...  \
-                       (don't panic... that will take a moment !!!!)\n", \
-                       CFG_MEMTEST_START, CFG_MEMTEST_END);
-#ifdef CFG_DRAM_TEST_DATA
-       if (rundata == 1) {
-               printf ("Test DATA ...  ");
-               if (mem_test_data () == 1) {
-                       printf ("failed \n");
-                       return 1;
-               } else
-                       printf ("ok \n");
-       }
-#endif
-#ifdef CFG_DRAM_TEST_ADDRESS
-       if (runaddress == 1) {
-               printf ("Test ADDRESS ...  ");
-               if (mem_test_address () == 1) {
-                       printf ("failed \n");
-                       return 1;
-               } else
-                       printf ("ok \n");
-       }
-#endif
-#ifdef CFG_DRAM_TEST_WALK
-       if (runwalk == 1) {
-               printf ("Test WALKING ONEs ...  ");
-               if (mem_test_walk () == 1) {
-                       printf ("failed \n");
-                       return 1;
-               } else
-                       printf ("ok \n");
-       }
-#endif
-       if ((rundata == 1) || (runaddress == 1) || (runwalk == 1))
-               printf ("passed\n");
-       return 0;
-
-}
-#endif /* CFG_DRAM_TEST */
-
 #if defined(CONFIG_OF_FLAT_TREE) && defined(CONFIG_OF_BOARD_SETUP)
 void
 ft_board_setup (void *blob, bd_t *bd)
index c9131a432ce70903dae4af8cc07990a9017c8cb6..38c382cf7c8cb1a698b93d1ece9561d73117b1ce 100644 (file)
 #define CFG_MAXARGS    16              /* max number of command args */
 #define CFG_BARGSIZE   CFG_CBSIZE      /* Boot Argument Buffer Size */
 
-/*
-#define CFG_DRAM_TEST
- *                     DRAM tests
- * CFG_DRAM_TEST - enables the following tests.
- *
- * CFG_DRAM_TEST_DATA - Enables test for shorted or open data lines
- *                     Environment variable 'test_dram_data' must be
- *                     set to 'y'.
- * CFG_DRAM_TEST_ADDRESS - Enables test to verify that each word
- *                     is uniquely addressable. Environment variable
- *                     'test_dram_address' must be set to 'y'.
- * CFG_DRAM_TEST_WALK - Enables test a 64-bit walking ones pattern test.
- *                     This test takes about 6 minutes to test 64 MB.
- *                     Environment variable 'test_dram_walk' must be
- *                     set to 'y'.
- */
-#undef CFG_DRAM_TEST
 #define CFG_MEMTEST_START      0x00400000      /* memtest works on */
 #define CFG_MEMTEST_END                0x07c00000      /* 4 ... 124 MB in DRAM */
-#if defined(CFG_DRAM_TEST)
-#define CFG_DRAM_TEST_DATA
-#define CFG_DRAM_TEST_ADDRESS
-#define CFG_DRAM_TEST_WALK
-#endif /* CFG_DRAM_TEST */
 
 #define CFG_LOAD_ADDR  0x00400000      /* default load address */