|
|
@@ -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)
|
roy zang