int test_synram_rw() {
int rv = TEST_PASS;
int i, j;
int seed = 1234;
unsigned row = 0;
for(i=0; i<REPETITIONS; i++) {
fxv_array_t wdata;
fxv_array_t rdata;
for(j=0; j<NUM_BYTES_PER_ARRAY; j++) {
wdata.bytes[j] = random_lcg(&seed) & 0x3f;
}
sync();
fxv_load_array(1, &wdata);
syn_store_weights(1, row);
syn_load_weights(2, row);
fxv_store_array(&rdata, 2);
sync();
for(j=0; j<NUM_WORDS_PER_ARRAY; j++) {
if( rdata.words[j] != wdata.words[j] ) {
rv = TEST_FAIL;
mailbox_write(8*4, (uint8_t*)&rdata, sizeof(rdata));
mailbox_write(8*4 + sizeof(rdata), (uint8_t*)&wdata, sizeof(wdata));
return rv;
}
}
row = random_lcg(&seed) % NUM_SYN_LOCATIONS;
}
return rv;
}
int test_cadc_conversion() {
int rv = TEST_PASS;
fxv_array_t converted_causal, converted_acausal;
fxv_array_t expected;
int i, j;
fxv_splatb(0, RST_CAUSAL | RST_ACAUSAL);
syn_reset(0, 0, COND_ALWAYS);
for(j=0; j<REPETITIONS; j++) {
for(i=0; i<NUM_BYTES_PER_ARRAY; ++i)
expected.bytes[i] = 0x19;
cadc_load_causal(1, 0);
cadc_load_acausal_buffered(2, 0);
fxv_store_array(&converted_causal, 1);
fxv_store_array(&converted_acausal, 2);
sync();
for(i=0; i<NUM_BYTES_PER_ARRAY; ++i) {
if( (expected.bytes[i] != converted_causal.bytes[i])
|| (expected.bytes[i] != converted_acausal.bytes[i]) ) {
rv = TEST_FAIL;
mailbox_write(8*4, (uint8_t*)&converted_causal, sizeof(converted_causal));
mailbox_write(8*4 + sizeof(converted_causal), (uint8_t*)&(converted_acausal), sizeof(converted_acausal));
return rv;
}
}
}
return rv;
}
int test_cadc_test_load() {
int i, j;
int rv = TEST_PASS;
int seed = 1234;
uint8_t a, c;
fxv_array_t causal_data;
fxv_array_t acausal_data;
for(j=0; j<REPETITIONS; j++) {
a = random_lcg(&seed);
c = random_lcg(&seed);
cadc_test_set(0, c, a);
cadc_test_load_causal(1, 0);
cadc_test_load_acausal(2, 0);
fxv_store_array(&causal_data, 1);
fxv_store_array(&acausal_data, 2);
sync();
for(i=0; i<NUM_BYTES_PER_ARRAY; i++) {
if( ((uint8_t)(causal_data.bytes[i]) != c) || ((uint8_t)(acausal_data.bytes[i]) != a) ) {
rv = TEST_FAIL;
mailbox_write(8*4, (uint8_t*)&causal_data, sizeof(causal_data));
mailbox_write(8*4 + sizeof(causal_data), (uint8_t*)&c, sizeof(c));
mailbox_write(8*4 + 2*sizeof(causal_data), (uint8_t*)&acausal_data, sizeof(acausal_data));
mailbox_write(8*4 + 3*sizeof(causal_data), (uint8_t*)&a, sizeof(a));
return rv;
}
}
}
return rv;
}
int test_synram_block_rw() {
static int const block_size = 10;
int rv = TEST_PASS;
int i;
unsigned j;
int k;
unsigned loc_start;
unsigned loc_stop;
fxv_array_t wdata[block_size];
int seed = 1234;
for(i=0; i<REPETITIONS; i++) {
// generate random data
for(j=0; j<block_size; ++j)
for(k=0; k<NUM_BYTES_PER_ARRAY; ++k)
wdata[j].bytes[k] = 0x3f & random_lcg(&seed);
loc_start = random_lcg(&seed) % NUM_SYN_LOCATIONS;
loc_stop = loc_start + 10;
if( loc_stop >= NUM_SYN_LOCATIONS )
loc_stop = NUM_SYN_LOCATIONS - 1;
sync(); // make sure random data is in memory
// write random data to synapse locations
for(j=loc_start; j < loc_stop; ++j) {
fxv_load_array(1, &(wdata[j - loc_start]));
syn_store_weights(1, j);
}
// readback and compare synapse data
for(j=loc_start; j<loc_stop; ++j) {
fxv_array_t rdata;
syn_load_weights(2, j);
fxv_store_array(&rdata, 2);
sync();
for(k=0; k<NUM_WORDS_PER_ARRAY; ++k) {
if( rdata.words[k] != wdata[j - loc_start].words[k] ) {
rv = TEST_FAIL;
mailbox_write(8*4, (uint8_t*)&rdata, sizeof(rdata));
mailbox_write(8*4 + sizeof(rdata), (uint8_t*)&(wdata[j - loc_start]), sizeof(wdata[j - loc_start]));
return rv;
}
}
}
}
return rv;
}
void start() {
struct {
int cadc_test_load;
int synram_rw;
int synram_block_rw;
int synram_block_rw_buffered;
int cadc_conversion;
int decoder_block_rw;
int cadc_test_conversion;
} result;
/*result.cadc_test_load = TEST_PASS;*/
/*result.synram_rw = TEST_PASS;*/
/*result.synram_block_rw = TEST_PASS;*/
/*result.synram_block_rw_buffered = TEST_PASS;*/
/*result.cadc_conversion = TEST_PASS;*/
/*result.decoder_block_rw = TEST_PASS;*/
/*result.cadc_test_conversion = TEST_PASS;*/
result.cadc_test_load = test_cadc_test_load();
result.synram_rw = test_synram_rw();
result.synram_block_rw = test_synram_block_rw();
result.synram_block_rw_buffered = test_synram_block_rw_buffered();
result.cadc_conversion = test_cadc_conversion();
result.decoder_block_rw = test_decoder_block_rw();
result.cadc_test_conversion = test_cadc_test_conversion();
mailbox_write(0, (uint8_t*)&result, sizeof(result));
}
/**
* Set up frame buffer.
*
* @param width Frame buffer width(less than 4096)
* @param height Frame buffer height(less than 4096)
* @param bit_depth less than 32 bits
* @return Pointer to frame buffer info. Return 0 if failed.
*/
FrameBufferInfo *init_framebuffer(int width, int height, int bit_depth) {
if (width > 4096)
goto ERROR;
if (height > 4096)
goto ERROR;
if (bit_depth > 32)
goto ERROR;
int response;
FrameBufferInfo *frameBuffer = &frameBufferInfo;
frameBuffer->p_width = width;
frameBuffer->p_height = height;
frameBuffer->v_width = width;
frameBuffer->v_height = height;
frameBuffer->gpu_pitch = 0;
frameBuffer->bit_depth = bit_depth;
frameBuffer->x = 0;
frameBuffer->y = 0;
frameBuffer->gpu_pointer = 0;
frameBuffer->gpu_size = 0;
int frameBufferAddr = (int)frameBuffer;
frameBufferAddr += 0x40000000;
// Write frame buffer to channel 1
mailbox_write(frameBufferAddr, 1);
response = mailbox_read(1);
if (response != 0)
return 0;
return frameBuffer;
ERROR:
return 0;
}
char *framebuffer_init(int x, int y, int depth) {
struct frame_buffer_info_type fb_info __attribute__ ((aligned(16)));;
int result;
fb_info.phys_x=x;
fb_info.phys_y=y;
fb_info.virt_x=x;
fb_info.virt_y=y;
fb_info.pitch=0;
fb_info.depth=depth;
fb_info.x=0;
fb_info.y=0;
fb_info.pointer=0;
fb_info.size=0;
if (debug) {
printk("fb: Writing message @%x to mailbox %x\r\n",
&fb_info,MAILBOX_BASE);
printk("fb: asking for ");
dump_framebuffer_info(&fb_info);
}
result=mailbox_write( (unsigned int)(&fb_info)+0x40000000 ,
MAILBOX_FRAMEBUFFER);
if (result<0) {
printk("Mailbox write failed\r\n");
return NULL;
}
result=mailbox_read(MAILBOX_FRAMEBUFFER);
if (debug) {
printk("fb: we got ");
dump_framebuffer_info(&fb_info);
}
if (result==-1) {
printk("Mailbox read failed\r\n");
return NULL;
}
current_fb.pointer=(int)(fb_info.pointer);
current_fb.phys_x=fb_info.phys_x;
current_fb.phys_y=fb_info.phys_y;
current_fb.pitch=fb_info.pitch;
current_fb.depth=fb_info.depth;
framebuffer_initialized=1;
return (char *)(fb_info.pointer);
}
void framebuf_init() {
framebuf_info.width = 1024;
framebuf_info.height = 768;
framebuf_info.vwidth = 1024;
framebuf_info.vheight = 768;
framebuf_info.pitch = 0;
framebuf_info.depth = 24;
framebuf_info.xoffset = 0;
framebuf_info.yoffset = 0;
framebuf_info.ptr = 0;
framebuf_info.size = 0;
mailbox_write(1, ((uint32)&framebuf_info) + 0x40000000);
mailbox_read(1);
};
void create_framebuffer(unsigned int width, unsigned int height , unsigned int colour_depth){
if(width > 4096) return;
if(height > 4096) return;
if(colour_depth > 32) return;
framebuffer_info[0] = width;
framebuffer_info[1] = height;
framebuffer_info[2] = width;
framebuffer_info[3] = height;
framebuffer_info[4] = 0;
framebuffer_info[5] = colour_depth;
framebuffer_info[6] = 0;
framebuffer_info[7] = 0;
framebuffer_info[8] = 0;
framebuffer_info[9] = 0;
mailbox_write((unsigned int)&framebuffer_info,1);
}
void* sort8k_entry3( void *data )
{
sortarg_t * my_arg;
void *ptr;
my_arg = (sortarg_t *)data;
//unsigned int tid = (unsigned int)hthread_self();
//unsigned int thread_number = ( unsigned int ) data;
while ( 1 ) {
// get pointer to next chunk of data
ptr = (void*)mailbox_read( &my_arg->mb_start );
// sort it
bubblesort3( ( unsigned int * ) ptr, N );
// return
mailbox_write( &my_arg->mb_done, (void*)23 ); // return any value
}
return NULL;
}
int initialize_framebuffer(uint32_t physical_w, uint32_t physical_h, uint32_t virtual_w, uint32_t virtual_h)
{
print_debug("Initializing framebuffer");
__screenbuffer->physical_width = physical_w;
__screenbuffer->physical_height = physical_h;
__screenbuffer->virtual_width = virtual_w;
__screenbuffer->virtual_height = virtual_h;
__screenbuffer->bit_depth = 32;
__screenbuffer->gpu_pointer = 0;
uint32_t read = 0;
while (__screenbuffer->gpu_pointer == 0)
{
if (mailbox_write(MAILBOX_FRAMEBUFFER, (uint32_t)(__screenbuffer) + 0x40000000) == -1) { return -1; }
read = mailbox_read(MAILBOX_FRAMEBUFFER);
}
return read;
}
void fb_init(unsigned width, unsigned height, unsigned depth, unsigned db)
{
// add code to handle double buffering
fb.width = width;
fb.virtual_width = width;
fb.height = height;
fb.virtual_height = height;
fb.depth = depth * 8; // convert number of bytes to number of bits
fb.x_offset = 0;
fb.y_offset = 0;
// set values returned by the GPU to 0; see mailbox manual
fb.pitch = 0;
fb.framebuffer = 0;
fb.size = 0;
mailbox_write(MAILBOX_FRAMEBUFFER, (unsigned)&fb + GPU_NOCACHE);
(void) mailbox_read(MAILBOX_FRAMEBUFFER);
}
int test_decoder_block_rw() {
static int const block_size = 10;
int rv = TEST_PASS;
int i;
unsigned j;
int k;
unsigned loc_start;
unsigned loc_stop;
fxv_array_t wdata[block_size];
fxv_array_t ddata[block_size];
int seed = 1234;
for(i=0; i<REPETITIONS; i++) {
// generate random data
for(j=0; j<block_size; ++j)
for(k=0; k<NUM_BYTES_PER_ARRAY; ++k) {
wdata[j].bytes[k] = 0x3f & random_lcg(&seed);
ddata[j].bytes[k] = 0x3f & random_lcg(&seed);
}
loc_start = random_lcg(&seed) % NUM_SYN_LOCATIONS;
loc_stop = loc_start + 10;
if( loc_stop >= NUM_SYN_LOCATIONS )
loc_stop = NUM_SYN_LOCATIONS - 1;
sync(); // make sure random data is in memory
// write random data to synapse locations
for(j=loc_start; j < loc_stop; ++j) {
fxv_load_array(1, &(wdata[j - loc_start]));
fxv_load_array(2, &(ddata[j - loc_start]));
syn_store_weights(1, j);
syn_store_decoders(2, j);
}
// readback and compare synapse data
for(j=loc_start; j<loc_stop; ++j) {
fxv_array_t rdata_w;
fxv_array_t rdata_d;
syn_load_weights(3, j);
syn_load_decoders(4, j);
fxv_store_array(&rdata_w, 3);
fxv_store_array(&rdata_d, 4);
sync();
for(k=0; k<NUM_WORDS_PER_ARRAY; ++k) {
if( rdata_w.words[k] != wdata[j - loc_start].words[k] ) {
/*rv = TEST_FAIL;*/
/*mailbox_write(8*4, (uint8_t*)&rdata_w, sizeof(rdata_w));*/
/*mailbox_write(8*4 + sizeof(rdata_w), (uint8_t*)&(wdata[j - loc_start]), sizeof(wdata[j - loc_start]));*/
return rv; //TODO it works if this is commented out. wtf
}
if( rdata_d.words[k] != ddata[j - loc_start].words[k] ) {
rv = TEST_FAIL;
mailbox_write(8*4, (uint8_t*)&rdata_d, sizeof(rdata_d));
mailbox_write(8*4 + sizeof(rdata_d), (uint8_t*)&(ddata[j - loc_start]), sizeof(ddata[j - loc_start]));
return rv;
}
}
}
}
return rv;
}
