jens
762e379c28
- testbench: refacored [denano] - testbench: fixed gpio git-svn-id: http://moon:8086/svn/mips@195 a8ebac50-d88d-4704-bea3-6648445a41b3
1077 lines
25 KiB
C
1077 lines
25 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
#include <sys/times.h>
|
|
#include <sys/time.h>
|
|
#include <libsys.h>
|
|
#include <gpio.h>
|
|
#include <irq.h>
|
|
|
|
#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_led_data;
|
|
gpio_if_t gpio_led_dir;
|
|
|
|
const uint32_t test_icache_instr[] =
|
|
{
|
|
0x27bdfff8, // addiu sp,sp,-8
|
|
0xafbe0004, // sw s8,4(sp)
|
|
0xafb00000, // sw s0,0(sp)
|
|
0x03a0f021, // move s8,sp
|
|
0x24100001, // li s0,1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x00108040, // sll s0,s0,0x1
|
|
0x02001021, // move v0,s0
|
|
0x03c0e821, // move sp,s8
|
|
0x8fbe0004, // lw s8,4(sp)
|
|
0x8fb00000, // lw s0,0(sp)
|
|
0x27bd0008, // addiu sp,sp,8
|
|
0x03e00008, // jr ra
|
|
0x00000000 // nop
|
|
};
|
|
|
|
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_led_data, 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");
|
|
interrupt_global_disable();
|
|
|
|
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;
|
|
}
|
|
interrupt_global_enable();
|
|
|
|
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 (8*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;
|
|
}
|
|
|
|
uint32_t test_Icache()
|
|
{
|
|
typedef uint32_t (*func_t)(void);
|
|
|
|
uint32_t *pInstr = malloc(sizeof(test_icache_instr));
|
|
memcpy(pInstr, test_icache_instr, sizeof(test_icache_instr));
|
|
func_t pF = (func_t)pInstr;
|
|
uint32_t v1;
|
|
uint32_t v2;
|
|
uint32_t v3;
|
|
|
|
interrupt_global_disable();
|
|
v1 = pF();
|
|
|
|
pInstr[4] = 0x24100002;
|
|
v2 = pF();
|
|
|
|
ICACHE_invalidate_at(&pInstr[4]);
|
|
v3 = pF();
|
|
interrupt_global_enable();
|
|
|
|
free(pF);
|
|
|
|
printf("v1 = %u\n", (unsigned)v1);
|
|
printf("v2 = %u\n", (unsigned)v2);
|
|
printf("v3 = %u\n", (unsigned)v3);
|
|
|
|
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;
|
|
// Init GPIO LED
|
|
gpio_init(&gpio_led_data, SYS_GPIO_0_DATA, GPIO_0_MASK_LED, GPIO_0_ALIGN_LED);
|
|
gpio_init(&gpio_led_dir, SYS_GPIO_0_DIR, GPIO_0_MASK_LED, GPIO_0_ALIGN_LED);
|
|
gpio_set(&gpio_led_dir, GPIO_0_MASK_LED);
|
|
|
|
*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_led_data, 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_led_data, 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");
|
|
|
|
printf("-------------------------------------------\n");
|
|
printf("-- D-Cache invalidate ---------------------\n");
|
|
printf("-------------------------------------------\n");
|
|
result = Test14_DCACHE_invalidate();
|
|
if (IS_ERROR(result))
|
|
break;
|
|
printf("passed\n\n");
|
|
|
|
printf("-------------------------------------------\n");
|
|
printf("-- PI calc --------------------------------\n");
|
|
printf("-------------------------------------------\n");
|
|
interrupt_global_disable();
|
|
result = Test15_pi_calc();
|
|
interrupt_global_enable();
|
|
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("-------------------------------------------\n");
|
|
printf("-- I-Cache test ---------------------------\n");
|
|
printf("-------------------------------------------\n");
|
|
result = test_Icache();
|
|
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;
|
|
|
|
}
|
|
|