From 7a38b812b2b8a68be6a713146d474a3519cfaac3 Mon Sep 17 00:00:00 2001 From: Jens Ahrensfeld Date: Sun, 22 Jan 2017 20:14:19 +0000 Subject: [PATCH] - added git-svn-id: http://moon:8086/svn/mips@123 a8ebac50-d88d-4704-bea3-6648445a41b3 --- src/testbench_denano.c | 1007 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1007 insertions(+) create mode 100644 src/testbench_denano.c diff --git a/src/testbench_denano.c b/src/testbench_denano.c new file mode 100644 index 0000000..b56118f --- /dev/null +++ b/src/testbench_denano.c @@ -0,0 +1,1007 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define TEST10_ERROR (ERROR | 0x1000) +#define TEST11_ERROR (ERROR | 0x1100) +#define TEST12_ERROR (ERROR | 0x1200) +#define TEST13_ERROR (ERROR | 0x1300) +#define TEST14_ERROR (ERROR | 0x1400) +#define TEST15_ERROR (ERROR | 0x1500) +#define TEST16_ERROR (ERROR | 0x1600) + +extern int paranoia(int argc, char **argv); + +gpio_if_t gpio_if; + + +uint32_t* pf(void) +{ + static uint32_t p; + + return &p; +} + +int IsEndianBig(void) +{ + uint8_t *pBuf; + uint32_t word; + word = 0x12345678; + pBuf = (uint8_t*)&word; + if (((*pBuf+0) == 0x12) && (*(pBuf+1) == 0x34) && (*(pBuf+2) == 0x56) && (*(pBuf+3) == 0x78)) + { + return 1; + } + if (((*pBuf+0) == 0x78) && (*(pBuf+1) == 0x56) && (*(pBuf+2) == 0x34) && (*(pBuf+3) == 0x12)) + { + return 0; + } + return -1; +} + +void handler3(struct xcptcontext *xcp) +{ + volatile uint32_t *pUART_stat = (uint32_t*)SYS_UART_STAT; + volatile uint32_t *pUART_data = (uint32_t*)SYS_UART_DATA; + + if((0x10 & *pUART_stat)) + { + _putchar(1, (char)*pUART_data); + } + +} + +int g_cnt; + +void handler7(struct xcptcontext *xcp) +{ + uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT; + uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL; + uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP; + time_t curr_date; + struct tm *pDate; + + if (*pTim_stat & 1) + { + *pTim_stat = 1; // Acknowledge IRQ + gpio_write(&gpio_if, GPIO_0_MASK_LED, GPIO_0_ALIGN_LED, GPIO_DATA_OFFSET, g_cnt++); + + *pTim0_cmp = (uint32_t)(rand() & 0x000FFFFF); + *pTim_ctrl |= 1; + } + + if (*pTim_stat & 4) + { + *pTim_stat = 4; + curr_date = time(NULL); + pDate = gmtime(&curr_date); + fprintf(stderr, "%s", asctime(pDate)); + } + +} + +int fibonacci(int f0, int f1, int *pDst, int len) +{ + int i; + + i = 0; + + pDst[i++] = f0; + pDst[i++] = f1; + + for (; i < len; i++) + { + pDst[i] = pDst[i-2] + pDst[i-1]; + } + + return i; +} + +void PrintCPUinfo(void) +{ + int result, rev_id; + int cache_size, cache_line; + int eb; + + char *cpu_type_str[7] = {"invalid", "R2000", "R3000", "R6000", "R4000", "reserved", "R6000A"}; + + // Print Status register + result = CP0_SR_read(); + + printf("--------------------------------------------------\n"); + printf("Status : %8.8X\n", result); + + // Print Revision + result = CP0_PRID_read(); + rev_id = (result >> 8) & 0xFF; + printf("CPU type : MIPS "); + if ((rev_id > 0) && (rev_id < 0x07)) + { + printf(cpu_type_str[rev_id]); + printf(" Rev. "); + rev_id = result & 0xFF; + printf("%d", rev_id); + } + else + printf("Unknown"); + + eb = IsEndianBig(); + if (eb) + printf(" [Big-endian]\n"); + if (!eb) + printf(" [Little-endian]\n"); + if (eb < 0) + printf(" [Unknown endian]\n"); + + cache_size = (result >> 16) & 7; + cache_line = (result >> 19) & 7; + printf("I-Cache : %d kBytes (%d Bytes per line)\n", 4*(int)pow(2.0, (double)(8+cache_size))/1024, 4*(int)pow(2.0, (double)(cache_line))); + cache_size = (result >> 24) & 7; + cache_line = (result >> 27) & 7; + printf("D-Cache : %d kBytes (%d Bytes per line)\n", 4*(int)pow(2.0, (double)(8+cache_size))/1024, 4*(int)pow(2.0, (double)(cache_line))); + printf("--------------------------------------------------\n"); + +} + +uint32_t uncached_cachemiss_bug(void) +{ + uint32_t result; + uint32_t pMem[2]; + + pMem[0] = 0x12345678; + pMem[1] = 0xFFFFFFFF; + + __asm__ + ( + "cop0 34\n" + "lui $s0, 0xA000\n" + "lw $a0, 48($s0)\n" + "or $s1, $a0, $0\n" + "or $a2, $0, $0\n" + "addiu $a2, 0x7F00\n" + "sw $a2, 48($s0)\n" +// "lw $a1, 0(%[pMem])\n" + "lw $a0, 48($s0)\n" + "lw $a2, 4(%[pMem])\n" + "lw $a1, 0(%[pMem])\n" + "nop\n" + "sw $s1, 48($s0)\n" + "or %[val], $a0, $0\n" + : [val] "=r" (result) + : [pMem] "r" (pMem) + : "a0", "a1", "a2", "s0", "s1" + ); + return result; +} + +uint32_t non_aligned_load() +{ + uint32_t result; + uint32_t pMem[3]; + + __asm__ + ( + "li $t0, 0x01234567\n" + "li $t1, 0x89ABCDEF\n" + "sw $t0, 0(%[pMem])\n" + "sw $t1, 4(%[pMem])\n" + "li %[val], 0x55555555\n" + "lw %[val], 0(%[pMem])\n" + "lwl %[val], 5(%[pMem])\n" + : [val] "=r" (result) + : [pMem] "r" (pMem) + : "t0", "t1" + ); + + if (0 == IsEndianBig()) + { + if (0xCDEF4567 != result) + return ERROR; + } + else + { + if (0xABCDEF67 != result) + return ERROR; + } + return 0; + +} + +int Test10_LoadStore() +{ + int *buf, i, result, data, err; + volatile int *pPtr; + + buf = (int*)malloc(32*sizeof(int)); +// sputs("buf = "); +// print_word((int)buf); +// sputs("\n"); + + while(1) + { + err = TEST10_ERROR; + // Basic Load/Store + pPtr = buf; + *pPtr++ = 0x00000000; + *pPtr++ = 0x55555555; + *pPtr++ = 0xAAAAAAAA; + *pPtr++ = 0xFFFFFFFF; + pPtr = buf; + if (*pPtr++ != 0x00000000) + break; + if (*pPtr++ != 0x55555555) + break; + if (*pPtr++ != 0xAAAAAAAA) + break; + if (*pPtr++ != 0xFFFFFFFF) + break; + + // Filling from left + pPtr = buf; + data = 0x00000000; + for (i=0; i < 32; i++) + { + *pPtr++ = data; + data = data >> 1 | 0x80000000; + + } + pPtr = buf; + data = 0x00000000; + for (i=0; i < 32; i++) + { + + if (*pPtr++ != data) + break; + + data = data >> 1 | 0x80000000; + } + if (i != 32) + break; + + // Filling from right + pPtr = buf; + data = 0x00000000; + for (i=0; i < 32; i++) + { + *pPtr++ = data; + data = data << 1 | 1; + + } + pPtr = buf; + data = 0x00000000; + for (i=0; i < 32; i++) + { + + if (*pPtr++ != data) + break; + + data = data << 1 | 1; + } + if (i != 32) + break; + + // Walking ones + pPtr = buf; + data = 0x00000001; + for (i=0; i < 32; i++) + { + *pPtr++ = data; + data = data << 1; + + } + pPtr = buf; + data = 0x00000001; + for (i=0; i < 32; i++) + { + + if (*pPtr++ != data) + break; + + data = data << 1; + } + if (i != 32) + break; + + // Walking zeros + pPtr = buf; + data = 0xFFFFFFFE; + for (i=0; i < 32; i++) + { + *pPtr++ = data; + data = data << 1 | 1; + + } + pPtr = buf; + data = 0xFFFFFFFE; + for (i=0; i < 32; i++) + { + + if (*pPtr++ != data) + break; + + data = data << 1 | 1; + + } + if (i != 32) + break; + + err = NO_ERROR; + break; + } + free(buf); + + if (IS_ERROR(err)) + return err; + + if (IS_ERROR(non_aligned_load())) + return TEST10_ERROR | 1; + + if (IS_ERROR(uncached_cachemiss_bug())) + return TEST10_ERROR | 2; + + return NO_ERROR; + +} + + +#define NUM_ELEMENTS 10000 +#define NUM_RUNS 3 +int Test11_AddSub() +{ + int buf[NUM_ELEMENTS], result, i, j, diff, fill, num_right_elements, num_right_runs; + + fill = 0xAAAAAAAA; + + num_right_runs = 0; + + for (i=0; i < NUM_RUNS; i++) + { + for (j=0; j < NUM_ELEMENTS; j++) + { + buf[j] = fill; + fill = ((fill ^ j) - 1) << 1; + } + num_right_elements = 2; + result = fibonacci(i, i+1, buf, NUM_ELEMENTS); + for (j=2; j < NUM_ELEMENTS; j++) + { + diff = buf[j] - buf[j-1]; + if (diff == buf[j-2]) + num_right_elements++; + } + if (num_right_elements == NUM_ELEMENTS) + num_right_runs++; + + } + + if (num_right_runs != NUM_RUNS) + return TEST11_ERROR; + + return NO_ERROR; +} + +int Test12_MulDiv() +{ + int mix, i, j; + int s1, s2, sp, st; + div_t div_res; + long cl; + + cl = (long)clock(); + srand(cl); + for (i=0; i < 100; i++) + { + for (j=1; j < 100; j++) + { + mix = (int)rand(); + mix = (mix << 8) ^ (mix << 16); + s1 = (int)rand() ^ mix; + mix = (int)rand(); + mix = (mix << 8) ^ (mix << 16); + s2 = (int)rand() ^ mix; + if (!s2) + { + fprintf(stderr, "Test12_MulDiv(): Division by zero!\n"); + fprintf(stderr, "Clock() was 0x%8.8X\n", cl); + continue; + } + + div_res = div(s1, s2); + + sp = s2*div_res.quot; + st = div_res.rem + sp; + if (st != s1) + return TEST12_ERROR; + } + } + return NO_ERROR; +} + +int Test13_COP0_Load_Store(void) +{ + int i,size; + uint32_t *pSrc32, *pDst32; + + size = 0x2000; + pSrc32 = (uint32_t*)0xBFC00000; + pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t)); + for (i=0; i < size/4; i++) + { + CP0_TR_read_ptr(&pSrc32[i]); + CP0_TR_write_ptr(&pDst32[i]); + } + for (i=size/4-1; i >= 0; i--) + if (pDst32[i] != pSrc32[i]) + break; + + free(pDst32); + i++; + if (i) + return TEST13_ERROR; + + return NO_ERROR; +} + +int Test14_DCACHE_invalidate(void) +{ + int i,size; + uint32_t *pSrc32, *pDst32; + + size = 0x2000; + pSrc32 = (uint32_t*)0xBFC00000; + pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t)); + for (i=0; i < size/4; i++) + { + pDst32[i] = pSrc32[i]; + DCACHE_invalidate_at(&pDst32[i]); + } + for (i=size/4-1; i >= 0; i--) + { + DCACHE_invalidate_at(&pDst32[i]); + if (pDst32[i] != pSrc32[i]) + break; + } + + free(pDst32); + i++; + if (i) + return TEST14_ERROR + 1; + + pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t)); + for (i=0; i < size/4; i++) + { + pDst32[i] = pSrc32[i]; + } + DCACHE_invalidate_all(); + for (i=size/4-1; i >= 0; i--) + if (pDst32[i] != pSrc32[i]) + break; + + free(pDst32); + i++; + if (i) + return TEST14_ERROR + 2; + + return NO_ERROR; +} + +#define PI_SCALE 10000 +#define PI_MAXARR 2800 +#define PI_ARRINIT 2000 + +int Test15_pi_calc() +{ + int i, j, k; + int carry = 0; + int arr[PI_MAXARR+1]; + uint32_t int_part, result; + uint16_t pi_res[200] = {0}; + uint16_t pi_ref[200] = + { + 3141,5926,5358,9793,2384,6264,3383,2795, 288,4197,1693,9937,5105,8209,7494,4592,3078,1640,6286,2089,9862,8034,8253,4211, + 7067,9821,4808,6513,2823, 664,7093,8446, 955, 582,2317,2535,9408,1284,8111,7450,2841, 270,1938,5211, 555,9644,6229,4895, + 4930,3819,6442,8810,9756,6593,3446,1284,7564,8233,7867,8316,5271,2019, 914,5648,5669,2346, 348,6104,5432,6648,2133,9360, + 7260,2491,4127,3724,5870, 660,6315,5881,7488,1520,9209,6282,9254, 917,1536,4367,8925,9036, 11,3305,3054,8820,4665,2138, + 4146,9519,4151,1609,4330,5727, 365,7595,9195,3092,1861,1738,1932,6117,9310,5118,5480,7446,2379,9627,4956,7351,8857,5272, + 4891,2279,3818,3011,9491,2983,3673,3624,4065,6643, 860,2139,4946,3952,2473,7190,7021,7986, 943,7027,7053,9217,1762,9317, + 6752,3846,7481,8467,6694, 513,2000,5681,2714,5263,5608,2778,5771,3427,5778,9609,1736,3717,8721,4684,4090,1224,9534,3014, + 6549,5853,7105, 792,2796,8925,8923,5420,1995,6112,1290,2196, 864, 344,1815,9813,6297,7477,1309,9605,1870,7211,3499,9999, + 8372,9780,4995,1059,7317,3281,6096,3185 + }; + + // setbuf(stdout, NULL); + k = 0; + for (i = 0; i <= PI_MAXARR; ++i) + arr[i] = PI_ARRINIT; + + for (i = PI_MAXARR; i; i -= 14) + { + int sum = 0; + for (j = i; j > 0; --j) + { + sum = sum*j + PI_SCALE*arr[j]; + arr[j] = sum % (j*2-1); + sum /= (j*2-1); + } + result = carry + sum/PI_SCALE; + int_part = PI_SCALE * (result / PI_SCALE); + pi_res[k] = (uint16_t)(result - int_part); + carry = sum % PI_SCALE; + k++; + } + + for (k=0; k < sizeof(pi_ref)/sizeof(uint16_t); k++) + { + printf("%d", pi_res[k]); + } + printf("\n"); + + if(memcmp(pi_res, pi_ref, sizeof(pi_ref))) + return TEST15_ERROR; + + return NO_ERROR; +} + +#define TEST_SIZE (16*1024*1024) // Bytes +#define SMALL_TEST_SIZE (8192) // Bytes +#define FLASH_SIZE (8*1024*1024) // Bytes + +int Test16_MemTest(void) +{ + int result, i, j, cnt, size; + uint8_t *ram8 = NULL; + uint16_t *ram16 = NULL; + uint32_t *ram32 = NULL; + uint32_t volatile *pFlashIO = (uint32_t*)SYS_FLASH_IO; + uint32_t volatile *pFlashMem = (uint32_t*)SYS_FLASH_MEM; + uint32_t volatile *pROM = (uint32_t*)0xBFC00000; + + + uint32_t *pSrc32, *pDst32; + uint32_t start, end; + uint32_t color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080}; + + // ---------------------------------------------------------- + // Memtest BEGIN + // ---------------------------------------------------------- + pSrc32 = (uint32_t*)calloc(TEST_SIZE/4,sizeof(uint32_t)); + pDst32 = (uint32_t*)calloc(TEST_SIZE/4,sizeof(uint32_t)); + + // Memtest BEGIN + printf("Dump first 16 bytes of flash blocks\n"); + for (i=0; i < FLASH_SIZE; i += 0x40000) + memdump((uint8_t*)(pFlashIO+i/4), 0, 16, 16); + + printf("\n"); + + printf("SDRAM Memory Test\n"); + printf("Test size %d kByte\n\n", TEST_SIZE/1024); + + ram8 = (uint8_t*)pDst32; + printf("Zeroize SDRAM (memset)..."); + start = clock(); + memset(ram8, 0, TEST_SIZE); + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + printf("Zeroize SDRAM (8-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE; i++) + ram8[i] = (uint8_t)0; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + ram16 = (uint16_t*)pDst32; + printf("Zeroize SDRAM (16-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE/2; i++) + ram16[i] = (uint16_t)0; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + ram32 = (uint32_t*)pDst32; + printf("Zeroize SDRAM (32-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE/4; i++) + ram32[i] = (uint32_t)0; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + ram8 = (uint8_t*)pDst32; + printf("Write SDRAM (8-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE; i++) + ram8[i] = (uint8_t)i; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + printf("Verify SDRAM (8-Bit access)..."); + start = clock(); + for (i=TEST_SIZE-1; i >= 0; i--) + if (ram8[i] != (uint8_t)i) + break; + + end = clock(); + i++; + if (i) + { + printf("failed\r\n"); + return TEST16_ERROR; + } + else + printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + ram16 = (uint16_t*)pDst32; + printf("Write SDRAM (16-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE/2; i++) + ram16[i] = (uint16_t)i; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + printf("Verify SDRAM (16-Bit access)..."); + start = clock(); + for (i=TEST_SIZE/2-1; i >= 0; i--) + if (ram16[i] != (uint16_t)i) + break; + + end = clock(); + i++; + if (i) + { + printf("failed\r\n"); + return TEST16_ERROR; + } + else + printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + + ram32 = (uint32_t*)pDst32; + printf("Write SDRAM (32-Bit access)..."); + start = clock(); + for (i=0; i < TEST_SIZE/4; i++) + { + ram32[i] = (uint32_t)i; + } + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + printf("Verify SDRAM (32-Bit access)..."); + start = clock(); + for (i=TEST_SIZE/4-1; i >= 0; i--) + { + if (ram32[i] != (uint32_t)i) + break; + } + + end = clock(); + i++; + if (i) + { + printf("failed\r\n"); + return TEST16_ERROR; + } + else + printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + printf("\n"); + printf("Small data test (size = %d kByte)\n", SMALL_TEST_SIZE/1024); + printf("Write SDRAM (32-Bit access)..."); + ram32 = (uint32_t*)pDst32; + start = clock(); + for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) + for (i=0; i < SMALL_TEST_SIZE/4; i++) + ram32[i] = (uint32_t)i; + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + // ------------------------------------------------------------------- + // Verify + printf("Verify SDRAM (32-Bit access)..."); + start = clock(); + for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) + for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--) + if (ram32[i] != (uint32_t)i) + break; + + end = clock(); + i++; + if (i) + { + printf("failed\r\n"); + return TEST16_ERROR; + } + else + printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + + for (i=1024; i < 4*65536; i *= 2) + { + printf("Memcpy() (%d kByte)...", i/1024); + start = clock(); + for (j=0; j < TEST_SIZE/i; j++) + memcpy(pDst32, pSrc32, i); + + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + } + // ------------------------------------------------------------------- + printf("\n"); + + printf("Memcpy() Flash(IO) => SDRAM \n"); + printf("Copying %d kBytes...", FLASH_SIZE/(1024)); + start = clock(); + memcpy(pDst32, (uint32_t*)pFlashIO, FLASH_SIZE); + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + printf("\n"); + + printf("Memcpy() Flash(MEM) => SDRAM \n"); + printf("Copying %d kBytes...", FLASH_SIZE/(1024)); + start = clock(); + memcpy(pDst32, (uint32_t*)pFlashMem, FLASH_SIZE); + end = clock(); + printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); + printf("\n"); + + size = 0x2000; + memcpy(pDst32, (uint32_t*)pROM, size); + printf("Verify boot ROM..."); + for (i=size/4-1; i >= 0; i--) + if (pDst32[i] != pROM[i]) + break; + i++; + if (i) + { + printf("failed\r\n"); + return TEST16_ERROR; + } + else + printf("passed\r\n"); + + DCACHE_invalidate_all(); + printf("pFlashIO = %08X\n", pFlashIO); + printf("pFlashMem = %08X\n", pFlashMem); + printf("Verify FLASH(IO) <=> FLASH(MEM)..."); + for (i=0; i < FLASH_SIZE/4; i++) + { + if (pFlashIO[i] != pFlashMem[i]) + { + printf("\nfailed at offset = %08X", i << 2); + printf("\nfound %08X <=> %08X", pFlashIO[i], pFlashMem[i]); + } + } + printf("\n"); + + if (i != FLASH_SIZE/4) + { + printf("failed\n"); + memdump((uint8_t*)&pFlashIO[i], 0, 16, 256); + memdump((uint8_t*)&pFlashMem[i], 0, 16, 256); + } + else + { + printf("passed\n"); + } + +// memdump((uint8_t*)pSrc32, 0, 16, size); +// memdump((uint8_t*)0x40000000, 0, 16, 1024); + + // Memtest END + // ---------------------------------------------------------- + free(pSrc32); + free(pDst32); + + sputs("\r\n"); + return 0; +} + +int main (void) +{ + int result, i, j, cnt, size; + uint32_t volatile *pUART_baud = (uint32_t*)SYS_UART_BAUD; + uint32_t volatile *pUART_stat = (uint32_t*)SYS_UART_STAT; + uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA; + uint32_t volatile *pReg_usec = (uint32_t*)SYS_TIMER_USEC; + uint32_t volatile *pReg_sec = (uint32_t*)SYS_TIMER_SEC; + uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL; + uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT; + uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT; + uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP; + uint32_t volatile *pTim1_cnt = (uint32_t*)SYS_ITIM1_CNT; + uint32_t volatile *pTim1_cmp = (uint32_t*)SYS_ITIM1_CMP; + + uint64_t *pBuf64_0, *pBuf64_1; + time_t curr_date; + struct tm *pDate, date; + uint32_t start, end; + char sel[80]; + struct timeval time_sec; + + g_cnt = 1; + gpio_init(&gpio_if, SYS_GPIO_0_BASE); + + *pTim0_cnt = 0; + *pTim1_cnt = 0; + *pTim0_cmp = 0x40000; + *pTim1_cmp = 100000000; + *pTim_stat = (1 << 2) | (1 << 0); + *pTim_ctrl = (3 << 2); + + setbuf(stdout, NULL); + PrintCPUinfo(); + + interrupt_register(SYS_INT_UART0, handler3); + fprintf(stderr, "UART interrupt registered.\n"); + + interrupt_register(SYS_INT_TIMER, handler7); + fprintf(stderr, "Timer interrupt registered.\n"); + + calibrate_delay(); + + printf("\n"); + + printf("Aktuelles Datum\n"); + curr_date = time(NULL); + pDate = gmtime(&curr_date); + puts(asctime(pDate)); + + if (curr_date < 2) + { + printf("Datum und Uhrzeit setzen? [j/N]: "); + scanf("%s", sel); + if (toupper(sel[0]) == 'J') + { + do + { + printf("Datum\n"); + printf("Jahr : "); + scanf("%d", &date.tm_year); + printf("Monat : "); + scanf("%d", &date.tm_mon); + printf("Tag : "); + scanf("%d", &date.tm_mday); + + printf("Uhrzeit\n"); + printf("Stunde : "); + scanf("%d", &date.tm_hour); + printf("Minute : "); + scanf("%d", &date.tm_min); + printf("Sekunde : "); + scanf("%d", &date.tm_sec); + + date.tm_year -= 1900; + date.tm_mon -= 1; + time_sec.tv_sec = mktime(&date); + time_sec.tv_usec = 0; + settimeofday(&time_sec, NULL); + + printf("Datum\n"); + curr_date = time(NULL); + pDate = gmtime(&curr_date); + puts(asctime(pDate)); + printf("\nOK? [J/n]: "); + scanf("%s", sel); + printf("sel=%d\n", (int)sel[0]); + + + } while(toupper(sel[0]) == 'N'); + } + } + srand(clock()); + gpio_write(&gpio_if, GPIO_0_MASK_LED, GPIO_0_ALIGN_LED, GPIO_DATA_OFFSET, uncached_cachemiss_bug()); + +// Test16_MemTest(); + + printf("pf = %08X\n", (uint32_t)pf()); + *pf() = 0x1234; + printf("*pf = %08X\n", (uint32_t)*pf()); + + interrupt_enable(SYS_INT_TIMER); + interrupt_enable(SYS_INT_UART0); + *pTim_ctrl |= 3; + *pUART_stat |= (1 << 6); + + cnt = 0; + while (1) + { + for (i=0; i < 100000; i++) + { + interrupt_disable(SYS_INT_TIMER); + } + for (i=0; i < 100000; i++) + { + interrupt_enable(SYS_INT_TIMER); + } + + gpio_write(&gpio_if, GPIO_0_MASK_LED, GPIO_0_ALIGN_LED, GPIO_DATA_OFFSET, cnt); + + printf("-------------------------------------------\n"); + printf("-- LoadStore ------------------------------\n"); + printf("-------------------------------------------\n"); + result = Test10_LoadStore(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); + + printf("-------------------------------------------\n"); + printf("-- AddSub ---------------------------------\n"); + printf("-------------------------------------------\n"); + result = Test11_AddSub(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); + + printf("-------------------------------------------\n"); + printf("-- MulDiv ---------------------------------\n"); + printf("-------------------------------------------\n"); + result = Test12_MulDiv(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); + + printf("-------------------------------------------\n"); + printf("-- Cop0 LWZ0 and SWC0 ---------------------\n"); + printf("-------------------------------------------\n"); + result = Test13_COP0_Load_Store(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); +#if 1 + printf("-------------------------------------------\n"); + printf("-- D-Cache invalidate ---------------------\n"); + printf("-------------------------------------------\n"); + result = Test14_DCACHE_invalidate(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); +#endif + printf("-------------------------------------------\n"); + printf("-- PI calc --------------------------------\n"); + printf("-------------------------------------------\n"); + result = Test15_pi_calc(); + if (IS_ERROR(result)) + break; + printf("passed\n\n"); + + printf("-------------------------------------------\n"); + printf("-- Paranoia -------------------------------\n"); + printf("-------------------------------------------\n"); + paranoia(1, NULL); + printf("passed\n\n"); + +// printf("-------------------------------------------\n"); +// printf("-- Mem Test -------------------------------\n"); +// printf("-------------------------------------------\n"); +// result = Test16_MemTest(); +// if (IS_ERROR(result)) +// break; +// printf("passed\n\n"); + + printf("Iteration %d: Passed\n", cnt); + curr_date = time(NULL); + pDate = gmtime(&curr_date); + puts(asctime(pDate)); + cnt++; + +// printf("V=%.17e\n", pow((double)cnt-1, (double)cnt)); + } + printf("Failed with error %8.8X\n", result); + + return 1; + +} +