printf ("\nDEVICES\n");	for (i = 0; i <= DEVICE3; i++) {		base = memoryGetDeviceBaseAddress (i);		size = memoryGetDeviceSize (i);		width = memoryGetDeviceWidth (i) * 8;		printf ("DEV %d:  base - 0x%08x  size - %dM bytes\twidth - %d bits", i, base, size >> 20, width);		if (i == 0)			printf ("\t- FLASH\n");		else if (i == 1)			printf ("\t- FLASH\n");		else if (i == 2)			printf ("\t- FLASH\n");		else			printf ("\t- RTC/REGS/CAN\n");	}	/* Bootrom */	base = memoryGetDeviceBaseAddress (BOOT_DEVICE);	/* Boot */	size = memoryGetDeviceSize (BOOT_DEVICE);	width = memoryGetDeviceWidth (BOOT_DEVICE) * 8;	printf (" BOOT:  base - 0x%08x  size - %dM bytes\twidth - %d bits\t- FLASH\n",		base, size >> 20, width);	return (0);}/* 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[] = {	0xaaaaaaaaaaaaaaaaLL,	0xccccccccccccccccLL,	0xf0f0f0f0f0f0f0f0LL,	0xff00ff00ff00ff00LL,	0xffff0000ffff0000LL,	0xffffffff00000000LL,	0x00000000ffffffffLL,	0x0000ffff0000ffffLL,	0x00ff00ff00ff00ffLL,	0x0f0f0f0f0f0f0f0fLL,	0x3333333333333333LL,	0x5555555555555555LL,};/*********************************************************************//* 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 = 0;	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 = 0;	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    = 0;	int runaddress = 0;	int runwalk    = 0;#ifdef CFG_DRAM_TEST_DATA	s = getenv ("testdramdata");	rundata = (s && (*s == 'y')) ? 1 : 0;#endif#ifdef CFG_DRAM_TEST_ADDRESS	s = getenv ("testdramaddress");	runaddress = (s && (*s == 'y')) ? 1 : 0;#endif#ifdef CFG_DRAM_TEST_WALK	s = getenv ("testdramwalk");	runwalk = (s && (*s == 'y')) ? 1 : 0;#endif	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 *//* ronen - the below functions are used by the bootm function           *//*  - we map the base register to fbe00000 (same mapping as in the LSP) *//*  - we turn off the RX gig dmas - to prevent the dma from overunning  *//*    the kernel data areas.                                            *//*  - we diable and invalidate the icache and dcache.                   */void my_remap_gt_regs_bootm (u32 cur_loc, u32 new_loc){	u32 temp;	temp = in_le32 ((u32 *) (new_loc + INTERNAL_SPACE_DECODE));	if ((temp & 0xffff) == new_loc >> 16)		return;	temp = (in_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE)) &		0xffff0000) | (new_loc >> 16);	out_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE), temp);	while ((WORD_SWAP (*((volatile unsigned int *) (NONE_CACHEABLE |							new_loc |							(INTERNAL_SPACE_DECODE)))))	       != temp);}void board_prebootm_init (){/* change window size of PCI1 IO in order tp prevent overlaping with REG BASE. */		GT_REG_WRITE (PCI_1_IO_SIZE, (_64K - 1) >> 16);/* Stop GigE Rx DMA engines */	GT_REG_WRITE (MV64360_ETH_RECEIVE_QUEUE_COMMAND_REG (0), 0x0000ff00);/*	GT_REG_WRITE (MV64360_ETH_RECEIVE_QUEUE_COMMAND_REG (1), 0x0000ff00); *//*      GV_REG_WRITE (MV64360_ETH_RECEIVE_QUEUE_COMMAND_REG (2), 0x0000ff00); *//* Relocate MV64360 internal regs */	my_remap_gt_regs_bootm (CFG_GT_REGS, CFG_DFL_GT_REGS);	icache_disable ();	invalidate_l1_instruction_cache ();	flush_data_cache ();	dcache_disable ();}