Description:

Enclosed is a patch to run memory tests using an interactive menu over the serial port in U-Boot.  The patch includes 1. serial_gets() routine 2. New memory tests 1. address/complement address test 2. pattern/complement pattern test 3. peek/poke routines 4. infinite memory test 5. Flash/Ram copy test

The tests are useful to have an interactive Bring Up Diagnostics for a system.

--- /login/asabharw/lxhome/u-boot-1.1.3/common/serial.c 2005-08-13 16:53:35.000000000 -0700 +++ u-boot-1.1.2/common/serial.c 2005-09-26 17:58:06.000000000 -0700 @@ -38,9 +38,6 @@ #elif defined(CONFIG_8xx_CONS_SCC1) || defined(CONFIG_8xx_CONS_SCC2) \ || defined(CONFIG_8xx_CONS_SCC3) || defined(CONFIG_8xx_CONS_SCC4) return &serial_scc_device; -#elif defined(CONFIG_405GP) || defined(CONFIG_405CR) || defined(CONFIG_440) \ - || defined(CONFIG_405EP) - return &serial0_device; #else #error No default console #endif @@ -74,12 +71,6 @@ serial_register (&serial_scc_device); #endif

-#if defined(CONFIG_405GP) || defined(CONFIG_405CR) || defined(CONFIG_440) \ - || defined(CONFIG_405EP) - serial_register(&serial0_device); - serial_register(&serial1_device); -#endif - serial_assign (default_serial_console ()->name); }

@@ -210,4 +201,17 @@ serial_current->puts (s); }

+void serial_gets (char *s) +{ + unsigned int c; + + c = serial_getc(); + /* Typically <enter> key is lf on linux systems. under minicom it is <cr>. maybe terminal settings ?? */ + while(( c != '\r') && (c != '\n')) + { + *s++ = (char)c; + c = serial_getc(); + } + return; +} #endif /* CONFIG_SERIAL_MULTI */ --- /login/asabharw/lxhome/u-boot-1.1.3/post/memory.c 2005-08-13 16:53:35.000000000 -0700 +++ u-boot-1.1.2/post/memory.c 2005-10-18 14:53:36.000000000 -0700 @@ -173,6 +173,28 @@ #endif

+#ifdef CFG_POST_MEMORY_INTERACTIVE +const static unsigned char testpattern[]= +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, + 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF +}; +#endif + /* * This function performs a double word move from the data at * the source pointer to the location at the destination pointer. @@ -222,6 +244,9 @@ const unsigned long long otherpattern = 0x0123456789abcdefULL;

+int pattern_copy_test(unsigned long address, unsigned long bytecount, unsigned char type); +int inverse_pattern_copy_test(unsigned long address, unsigned long bytecount, unsigned char type); + static int memory_post_dataline(unsigned long long * pmem) { unsigned long long temp64; @@ -413,6 +438,115 @@ return ret; }

+ + +/* This is a thorough address/data line test by writting the address value as * + * data value on the memory part. */ +int memory_combined_address_data_line_test(const unsigned long start, const unsigned long end) +{ + volatile unsigned long * startptr; + unsigned long data; + + printf("Write cycle\n"); + for( startptr = (unsigned long *) start; startptr < (unsigned long *) end; startptr++ ) + { + *startptr = (unsigned long) startptr; + } + + printf("Verify cycle\n"); + for( startptr = (unsigned long *) start; startptr < (unsigned long *) end; startptr++ ) + { + /* Need to read once from the memory location as subsequent read maybe fine */ + data = *startptr; + if(data != (unsigned long) startptr) + { + printf("Data mismatch at address %p Expected 0x%08x. Value 0x%08x\n\n", (unsigned long) startptr, + (unsigned long)startptr, data); + return -1; + } + } + printf("Test Passed\n"); + return 0; +} + +/* This is a thorough address/data line test by writting the inverse of address value as * + * data value on the memory part. */ +int memory_combined_inverse_address_data_line_test(const unsigned long start, const unsigned long end) +{ + volatile unsigned long * startptr; + unsigned long data; + + printf("Write cycle\n"); + for( startptr = (unsigned long *) start; startptr < (unsigned long *) end; startptr++ ) + { + *startptr = ~((unsigned long) startptr); + } + + printf("Verify cycle\n"); + for( startptr = (unsigned long *) start; startptr < (unsigned long *) end; startptr++ ) + { + /* Need to read once from the memory location as subsequent read maybe fine */ + data = *startptr; + if(data != (~(unsigned long) startptr)) + { + printf("Data mismatch at address %p Expected 0x%08x. Value 0x%08x\n\n", (unsigned long) startptr, + (~(unsigned long)startptr), data); + return -1; + } + } + printf("Test Passed\n"); + return 0; +} +static void memory_read(unsigned long location) +{ + int subchoice; + + + printf("Read mode [ b : byte, h : half word , w : word , d : double word ] : "); + subchoice = serial_getc(); + printf("\n\n"); + + switch(subchoice) + { + /* Byte Read */ + case 'b' : + { + unsigned char * ptr = (unsigned char *) location; + printf("\n\nByte Value at location %p is 0x%02x \n\n", location, *ptr ); + } + break; + + /* Half word Read */ + case 'h' : + { + unsigned short * ptr = (unsigned short *) location; + printf("\n\n16 bit Value at location %p is 0x%04x \n\n", location, *ptr); + } + break; + + /* Word Read */ + case 'w' : + { + unsigned long * ptr = (unsigned long *) location; + printf("\n32 bit Value at location %p is 0x%08x \n\n", location, *ptr); + } + break; + + /* Double Word Read */ + case 'd' : + { + unsigned long long * ptr = (unsigned long long *) location; + printf("\n64 bit Value at location %p is 0x%08x%08x \n\n", location, + *(unsigned long *)ptr, *(((unsigned long *) ptr)+1)); + } + break; + + default: + printf("\nInvalid Choice\n"); + } + return; +} + static int memory_post_tests (unsigned long start, unsigned long size) { int ret = 0; @@ -447,7 +581,30 @@ WATCHDOG_RESET (); if (ret == 0) ret = memory_post_test4 (start, size); + WATCHDOG_RESET (); + if (ret == 0) + ret = pattern_copy_test(start, size, 'm'); + WATCHDOG_RESET (); + if (ret == 0) + ret = memory_combined_address_data_line_test(start, (start + (size & 0xFFFFFFFC))); + WATCHDOG_RESET (); + if (ret == 0) + ret = memory_combined_inverse_address_data_line_test(start, (start + (size & 0xFFFFFFFC))); + WATCHDOG_RESET (); + if (ret == 0) + ret = pattern_copy_test(start, size, 'b'); + WATCHDOG_RESET (); + if (ret == 0) + ret = inverse_pattern_copy_test(start, size, 'h'); WATCHDOG_RESET (); + if (ret == 0) + ret = pattern_copy_test(start, size, 'w'); + WATCHDOG_RESET (); + if (ret == 0) + ret = inverse_pattern_copy_test(start, size, 'd'); + WATCHDOG_RESET (); + if (ret == 0) + ret = pattern_copy_test(start, size, 's');

return ret; } @@ -478,5 +635,589 @@ return ret; }

+#warning "printf prints junk when we have a parameter in format string but no argument" + +static void memory_write(const unsigned long location) +{ + int subchoice; + unsigned char input[32]; + unsigned long long data; + + + memset(input, 0, strlen(input)); + printf("Write mode [ b : byte, h : half word , w : word , d : double word ] : "); + subchoice = serial_getc(); + printf("\n\n"); + + switch(subchoice) + { + /* Byte write */ + case 'b' : + { + unsigned char * ptr = (unsigned char *) location; + + printf("Enter Data : 0x "); + serial_gets(input); + data = simple_strtoul(input, NULL, 16); + + /* Write Data */ + *ptr = (unsigned char) data; + printf("\n\nByte Value at location %p is 0x%02x \n\n", location, *ptr); + } + break; + + /* Half Word Write */ + case 'h' : + { + unsigned short * ptr = (unsigned short *) location; + + printf("Enter Data : 0x "); + serial_gets(input); + data = simple_strtoul(input, NULL, 16); + + /* Write Data */ + *ptr = (unsigned short) data; + printf("\n\n16 bit Value at location %p is 0x%04x \n\n", location, *ptr); + } + break; + + /* Single word write */ + case 'w' : + { + unsigned long * ptr = (unsigned long *) location; + + printf("Enter Data : 0x "); + serial_gets(input); + data = simple_strtoul(input, NULL, 16); + + /* Write Data */ + *ptr = (unsigned long) data; + printf("\n32 bit Value at location %p is 0x%08x \n\n", location, *ptr); + } + break; + + /* Double word write */ + case 'd' : + { + unsigned long long * ptr = (unsigned long long *) location; + + printf("Enter Data : 0x "); + serial_gets(input); + data = simple_strtoul(input, NULL, 16); + + /* Write Data */ + *ptr = (unsigned long long) data; + printf("\nByte Value at location %p is 0x%08x%08x \n\n", location, + *(unsigned long *)ptr, *(((unsigned long *) ptr)+1)); + } + break; + + + default: + printf("\nInvalid Choice\n"); + } + return; +} + +#define MAX_BLOCKS 16 + +int flash_block_copy_test(unsigned long RamAddress, unsigned long bytecount, unsigned long blockSize) +{ + // break test region into max 16 equal sized blocks + /* We copy U-Boot code around as we can compare/verify with JTAG & network dump's*/ + const unsigned long flashBase = CFG_FLASH_BASE; + unsigned long blockStart[MAX_BLOCKS]; + unsigned long blockEnd[MAX_BLOCKS]; + unsigned int numBlocks = ((bytecount / blockSize ) % MAX_BLOCKS); + int index; + + blockStart[0] = RamAddress; + + //Setup start & end address for each block + for( index = 0; index < numBlocks ; index++ ) + { + blockEnd[index] = (blockStart[index] + blockSize) - 1; + blockStart[index + 1] = blockEnd[index] + 1; + } + blockEnd[index] = (blockStart[index] + blockSize) - 1; + + printf("\n"); + for( index = 0; index < numBlocks; index++ ) + { + printf( "block %d: %08x - %08x\n", index, blockStart[index], blockEnd[index] ); + } + + /* initialize block 0 with contents from the flash ROM. Duplicate remaining */ + /* 15 blocks. COPY CYCLE. */ + printf("Copy cycle\n"); + memcpy((void *)blockStart[0], (void *)flashBase, blockSize); + for (index = 1; index < numBlocks; index++) + { + memcpy((void *)blockStart[index], (void *)blockStart[index - 1], blockSize); + } + + /* Verify CYCLE. */ + printf("Verify cycle\n"); + for( index = 1; index < numBlocks; index++ ) + { + if(memcmp((void *) blockStart[index], (void *) blockStart[0], blockSize) != 0) + { + printf("Verification error at block %d\n", index); + return -1; + } + } + return 0; +} + +int pattern_copy_test(unsigned long address, unsigned long bytecount, unsigned char type) +{ + unsigned int i = 0; + + switch(type) + { + /* Byte Copy Test */ + case 'b': + { + /* Write Cycle */ + printf("\n%u byte copy test starting at address %p\n", sizeof(unsigned char), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned char)) + *((unsigned char *) (address + i) ) = (unsigned char) *(testpattern + (i % sizeof(testpattern))); + + printf("read cycle\n"); + /* Read Cycle */ + for( i = 0; i < bytecount; i += sizeof(unsigned char)) + if(*((unsigned char *) (address + i) ) != (unsigned char) *(testpattern + (i % sizeof(testpattern)))) + { + printf("Data mismatch at address %p Value : 0x%02x Expected : 0x%02x\n\n", + address + i, *((unsigned char *)(address + i)),

+ (unsigned char) *(testpattern + ( i % sizeof(testpattern)))); + return -1; + } + + } + break; + + /* 16 bit Copy Test */ + case 'h': + { + /* Write Cycle */ + printf("\n%u byte copy test starting at address %p\n", sizeof(unsigned short), address); + printf("write cycle\n"); + for( i = 0; i < bytecount ; i += sizeof(unsigned short)) + *((unsigned short *) (address + i) ) = + *(unsigned short *)(testpattern + (i % sizeof(testpattern))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount ; i += sizeof(unsigned short)) + if(*((unsigned short *) (address + i) ) != + *(unsigned short *)(testpattern + (i % sizeof(testpattern)))) + { + printf("Data mismatch at address %p Value : 0x%04x Expected : 0x%04x\n\n", + (address + i), *((unsigned short *)address + i), + *(unsigned short *)(testpattern + ( i % sizeof(testpattern)))); + return -1; + } + } + break; + + /* 32 bit Copy Test */ + case 'w': + { + /* Write Cycle */ + printf("\n%u byte copy test starting at address %p\n\n", sizeof(unsigned int), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned int)) + *((unsigned int *) (address + i) ) = + *(unsigned int *)(testpattern + (i % sizeof(testpattern))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned int)) + if(*((unsigned int *) (address + i) ) != + *(unsigned int *)(testpattern + (i % sizeof(testpattern)))) + { + printf("Data mismatch at address %p Value : 0x%08x Expected : 0x%08x\n", + address + i, *(unsigned int *)(address + i), + *(unsigned int *)(testpattern + ( i % sizeof(testpattern)))); + return -1; + } + } + break; + + /* 64 bit copy test */ + case 'd': + { + /* Write Cycle */ + printf("\n%u byte copy test starting at address %p\n\n", sizeof(unsigned long long), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned long long)) + *((unsigned long long *) (address + i) ) = + *(unsigned long long *)(testpattern + (i % sizeof(testpattern))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned long long)) + if(*((unsigned long long *) (address + i) ) != + *(unsigned long long *)(testpattern + (i % sizeof(testpattern)))) + { + printf("Data mismatch at address %p Value : 0x%08x%08x Expected : 0x%08x%08x\n", + address + i, *(unsigned long *)(address + i), + *(unsigned long *)(address + i + sizeof(unsigned long)), + *(unsigned long *)(testpattern + ( i % sizeof(testpattern))), + *(unsigned long *)(testpattern + ( (i + sizeof(unsigned long)) % sizeof(testpattern)))); + return -1; + } + } + break; + + /* strncpy based block copy */ + case 's': + { + unsigned short pattern_length = sizeof(testpattern); + unsigned long blockcount = 0; + + /* Write Cycle */ + printf("\nstrncpy test starting at address %p\n\n", address); + printf("write cycle with pattern size of %u\n", pattern_length); + for( i = 0; i < bytecount; i += pattern_length, blockcount+=1) + strncpy(address + i, testpattern, pattern_length); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; (i < bytecount) && (blockcount); i += pattern_length) + { + if(strncmp(address + i, testpattern, pattern_length) != 0) + { + printf("Data mismatch on block %u\n", blockcount); + return -1; + } + } + printf("strcpy based Block Copy Test Passed\n"); + return 0; + } + break; + + /* bcopy/memcpy based block copy */ + /* Note: In ppc_String.S, the strncpy code is less computation intensive. Hence, * + * two different versions of the test as different timing behavior. */ + case 'm': + { + unsigned short pattern_length = sizeof(testpattern); + unsigned long blockcount = 0; + + /* Write Cycle */ + printf("\nmemcpy test starting at address %p\n\n", address); + printf("write cycle with pattern size of %u\n", pattern_length); + for( i = 0; i < bytecount; i += pattern_length, blockcount+=1) + memcpy(address + i, testpattern, pattern_length); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; (i < bytecount) && (blockcount); i += pattern_length) + { + if(memcmp(address + i, testpattern, pattern_length) != 0) + { + printf("Data mismatch on block %u\n", blockcount); + return -1; + } + } + printf("memcpy based Block Copy Test Passed\n"); + return 0; + } + } + + if (i >= bytecount) + printf("Test Passed.\n"); + return 0; +} + +/* The inverse of pattern copy is a seperate test to keep the memory load at a higher rate */ +int inverse_pattern_copy_test(unsigned long address, unsigned long bytecount, unsigned char type) +{ + unsigned int i; + + switch(type) + { + /* Byte Copy Test */ + case 'b': + { + /* Write Cycle */ + printf("\n%u inverse byte copy test starting at address %p\n", sizeof(unsigned char), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned char)) + *((unsigned char *) (address + i) ) = (unsigned char) ~(*(testpattern + (i % sizeof(testpattern)))); + + printf("read cycle\n"); + /* Read Cycle */ + for( i = 0; i < bytecount; i += sizeof(unsigned char)) + if(*((unsigned char *) (address + i) ) != (unsigned char)(~(*(testpattern + (i % sizeof(testpattern)))))) + { + printf("Data mismatch at address %p Value : 0x%02x Expected : 0x%02x\n\n", + address + i, *((unsigned char *)(address + i)),

+ (unsigned char)~(*(testpattern + ( i % sizeof(testpattern))))); + return -1; + } + + } + break; + + /* 16 bit Copy Test */ + case 'h': + { + /* Write Cycle */ + printf("\n%u inverse byte copy test starting at address %p\n", sizeof(unsigned short), address); + printf("write cycle\n"); + for( i = 0; i < bytecount ; i += sizeof(unsigned short)) + *((unsigned short *) (address + i) ) = + (unsigned short)~(*(unsigned short *)(testpattern + (i % sizeof(testpattern)))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount ; i += sizeof(unsigned short)) + if(*((unsigned short *) (address + i) ) != + ((unsigned short)~(*(unsigned short *)(testpattern + (i % sizeof(testpattern)))))) + { + printf("Data mismatch at address %p Value : 0x%04x Expected : 0x%04x\n\n", + (address + i), *((unsigned short *)address + i), + (unsigned short)~(*(unsigned short *)(testpattern + ( i % sizeof(testpattern))))); + return -1; + } + } + break; + + /* 32 bit Copy Test */ + case 'w': + { + /* Write Cycle */ + printf("\n%u inverse byte copy test starting at address %p\n\n", sizeof(unsigned int), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned int)) + *((unsigned int *) (address + i) ) = + (unsigned int)(~(*(unsigned int *)(testpattern + (i % sizeof(testpattern))))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned int)) + if(*((unsigned int *) (address + i) ) != + (~(*(unsigned int *)(testpattern + (i % sizeof(testpattern)))))) + { + printf("Data mismatch at address %p Value : 0x%08x Expected : 0x%08x\n", + address + i, *(unsigned int *)(address + i), + (unsigned int)(~(*(unsigned int *)(testpattern + ( i % sizeof(testpattern)))))); + return -1; + } + } + break; + + /* 64 bit copy test */ + case 'd': + { + /* Write Cycle */ + printf("\n%u inverse byte copy test starting at address %p\n\n", sizeof(unsigned long long), address); + printf("write cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned long long)) + *((unsigned long long *) (address + i) ) = + (unsigned long long) (~(*(unsigned long long *)(testpattern + (i % sizeof(testpattern))))); + + /* Read Cycle */ + printf("read cycle\n"); + for( i = 0; i < bytecount; i += sizeof(unsigned long long)) + if(*((unsigned long long *) (address + i) ) != + (unsigned long long)(~(*(unsigned long long *)(testpattern + (i % sizeof(testpattern)))))) + { + printf("Data mismatch at address %p Value : 0x%08x%08x Expected : 0x%08x%08x\n", + address + i, *(unsigned long *)(address + i), + *(unsigned long *)(address + i + sizeof(unsigned long)), + (unsigned long)~(*(unsigned long *)(testpattern + ( i % sizeof(testpattern)))), + (unsigned long)~(*(unsigned long *)(testpattern + ( (i + sizeof(unsigned long)) % sizeof(testpattern))))); + return -1; + } + } + break; + } + + if (i >= bytecount) + printf("Test Passed.\n"); + return 0; +} + +#ifdef CFG_POST_MEMORY_INTERACTIVE +int memory_test_interactive(void) +{ + + int choice, subchoice; + unsigned long address = 0; + unsigned long bytecount = 0; + unsigned char input[32]; + unsigned int j = 0; + int i; + + for(;;) + { + memset(input, 0, strlen(input)); + + printf("0 memory post dataline test\n"); + printf("1 memory post addrline test\n"); + printf("2 memory_post_test1\n"); + printf("3 memory_post_test2\n"); + printf("4 memory_post_test3\n"); + printf("5 memory_post_test4\n"); + printf("6 pattern copy test\n"); + printf("7 inverse pattern copy test\n"); + printf("a combined address/data line test\n"); + printf("b Inverse combined address/data line test\n"); + printf("c memory peek test\n"); + printf("d memory poke test\n"); + printf("i Infinite memory tests over entire 64MB\n"); + printf("j Flash/Ram Block Copy Test\n"); + printf("e exit & proceed to normal execution\n\n\n"); + + printf("Test to perform ? "); + choice = serial_getc(); + + if(choice == 'e') + break; + + /* Start address to test memory. Could be on a odd/even boundary */ + printf("\n\nTest Selected %c\n", choice); + printf("\n\nMemory Address to verify : 0x "); + serial_gets(input); + address = simple_strtoul(input, NULL, 16); + + /* We do not test length size for simple address/data line test to memory read operation */ + if (( choice != '0' ) && (choice != '1') && (choice != 'c') && (choice != 'd')) + { + /* Amount of test pattern to write & verify */ + printf("\n\nLength of test : 0x"); + serial_gets(input); + bytecount = simple_strtoul(input, NULL, 16); + } + + switch(choice) + { + + case '0': + printf("\nDoing simplified Data Line test at address %p.\n", address); + if(memory_post_dataline((unsigned long long *) address) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '1': + printf("\nDoing simplified Address Line test at address %p.\n", address); + if( memory_post_addrline((unsigned long *) address, (unsigned long *) address, bytecount) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '2': + printf("\nDoing POST Test1 at address %p. Bytecount 0x%08x\n", address, bytecount); + if( memory_post_test1((unsigned long ) address, bytecount, 0xCC55AAFF) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '3': + printf("\nDoing POST Test2 at address %p. Bytecount 0x%08x\n", address, bytecount); + if( memory_post_test2((unsigned long ) address, bytecount) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '4': + printf("\nDoing POST Test3 at address %p. Bytecount 0x%08x\n", address, bytecount); + if( memory_post_test3((unsigned long ) address, bytecount) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '5': + printf("\nDoing POST Test4 at address %p. Bytecount 0x%08x\n", address, bytecount); + if( memory_post_test4((unsigned long )address, bytecount) != 0) + printf("Test Failed\n\n"); + else + printf("Test Passed\n\n"); + break; + + case '6': + printf("Test mode [ b : byte, h : half word , w : word , d : double word," \ + " s : strncpy, m : memcpy ] : "); + subchoice = serial_getc(); + printf("\n\n"); + pattern_copy_test(address, bytecount, subchoice); + break; + + case '7': + printf("Test mode [ b : byte, h : half word , w : word , d : double word ] : "); + subchoice = serial_getc(); + printf("\n\n"); + inverse_pattern_copy_test(address, bytecount, subchoice); + break; + + case 'a': + case 'b': + { + if(choice == 'a') + { + memory_combined_address_data_line_test(address, (address + bytecount )); + } + else + { + memory_combined_inverse_address_data_line_test(address, (address + bytecount )); + } + } + break; + + case 'c': + memory_read(address); + break; + + case 'd': + memory_write(address); + break; + + case 'i': + j = 0; + while(1) + { + + printf("ITN:%u\n", j ); + if(memory_post_tests(address, bytecount) != 0) + break; + //Wait for 2000 ticks. Based on Timebase register + wait_ticks(20000); + j++; + } + break; + + case 'j': + { + unsigned short blockSize; + + printf("\n\nBlock Size : 0x "); + serial_gets(input); + blockSize = simple_strtoul(input, NULL, 16); + if(blockSize > 512*1024 ) + { + printf("We have a 8MB flash. So, max block size is 512KB\n"); + } + flash_block_copy_test(address, bytecount, blockSize); + } + break; + + default: + printf("Invalid Choice\n"); + } + } + return 0; +} +#endif #endif /* CONFIG_POST & CFG_POST_MEMORY */ #endif /* CONFIG_POST */ --- /login/asabharw/lxhome/u-boot-1.1.3/post/tests.c 2005-08-13 16:53:35.000000000 -0700 +++ u-boot-1.1.2/post/tests.c 2005-10-10 14:30:11.000000000 -0700 @@ -45,6 +45,7 @@ extern int sysmon_post_test (int flags); extern int dsp_post_test (int flags); extern int codec_post_test (int flags); +extern int memory_test_interactive(void);

extern int sysmon_init_f (void);

@@ -58,7 +59,7 @@ "Cache test", "cache", "This test verifies the CPU cache operation.", - POST_RAM | POST_ALWAYS, + POST_POWERON | POST_RAM | POST_ALWAYS, &cache_post_test, NULL, NULL, @@ -113,6 +114,18 @@ CFG_POST_MEMORY }, #endif +#if CONFIG_POST & CFG_POST_MEMORY_INTERACTIVE + { + "Memory test interactive", + "memory controller", + "This test checks external memory controller.", + POST_ROM | POST_POWERON | POST_ALWAYS | POST_SLOWTEST | POST_PREREL, + &memory_test_interactive, + NULL, + NULL, + CFG_POST_MEMORY_INTERACTIVE + }, +#endif #if CONFIG_POST & CFG_POST_CPU { "CPU test", --- /login/asabharw/lxhome/u-boot-1.1.3/include/post.h 2005-08-13 16:53:35.000000000 -0700 +++ u-boot-1.1.2/include/post.h 2005-10-06 11:58:47.000000000 -0700 @@ -77,20 +77,21 @@

#endif /* __ASSEMBLY__ */

-#define CFG_POST_RTC 0x00000001 -#define CFG_POST_WATCHDOG 0x00000002 -#define CFG_POST_MEMORY 0x00000004 -#define CFG_POST_CPU 0x00000008 -#define CFG_POST_I2C 0x00000010 -#define CFG_POST_CACHE 0x00000020 -#define CFG_POST_UART 0x00000040 -#define CFG_POST_ETHER 0x00000080 -#define CFG_POST_SPI 0x00000100 -#define CFG_POST_USB 0x00000200 -#define CFG_POST_SPR 0x00000400 -#define CFG_POST_SYSMON 0x00000800 -#define CFG_POST_DSP 0x00001000 -#define CFG_POST_CODEC 0x00002000 +#define CFG_POST_RTC 0x00000001 +#define CFG_POST_WATCHDOG 0x00000002 +#define CFG_POST_MEMORY 0x00000004 +#define CFG_POST_CPU 0x00000008 +#define CFG_POST_I2C 0x00000010 +#define CFG_POST_CACHE 0x00000020 +#define CFG_POST_UART 0x00000040 +#define CFG_POST_ETHER 0x00000080 +#define CFG_POST_SPI 0x00000100 +#define CFG_POST_USB 0x00000200 +#define CFG_POST_SPR 0x00000400 +#define CFG_POST_SYSMON 0x00000800 +#define CFG_POST_DSP 0x00001000 +#define CFG_POST_CODEC 0x00002000 +#define CFG_POST_MEMORY_INTERACTIVE 0x00004000

#endif /* CONFIG_POST */