void comm_proceed(uint8_t data)
{
if (comm_recv_error && data != 'F') return;
comm_recv_error = 0;
if (!comm_recv_pos)
{
comm_recv_crc = 0;
comm_recv_done = 0;
}
comm_calc_recv_crc(data);
unsigned int l = comm_recv_pos-4;
switch (comm_recv_pos)
{
case 0:
if (data != 'F')
{
comm_recv_error = 1;
comm_start(COMMAND_ERROR_INVALID, 0);
}
break;
case 1:
comm_recv_command = data;
break;
case 2:
comm_recv_length = data;
break;
case 3:
comm_recv_length |= (uint16_t)data << 8;
break;
default:
if (l >= RECV_BUFFER)
{
comm_recv_pos = 0;
comm_recv_error = 1;
comm_start(COMMAND_ERROR_OVERFLOW, 0);
return;
}
else if (l < comm_recv_length)
{
recv_buffer[l] = data;
} else if (l == comm_recv_length)
{
if (!comm_recv_crc)
{
comm_recv_done = 1;
}
else
{
comm_recv_error = 1;
comm_start(COMMAND_ERROR_CRC, 0);
}
comm_recv_pos = 0;
return;
}
break;
}
comm_recv_pos++;
}
static void read_prg_send(unsigned int address, unsigned int len)
{
LED_GREEN_ON;
MODE_READ;
comm_start(COMMAND_PRG_READ_RESULT, len);
while (len > 0)
{
comm_send_byte(read_prg_byte(address));
len--;
address++;
}
LED_GREEN_OFF;
}
int df_init() {
DFDEBUG("Starting init");
comm_start(2, process_incoming_rget);
// setup formatting
formatting_init();
formatting_add_rule("\\\\[\\[\\]\"]", "\"");
DFDEBUG("Finished init");
return 0;
}
void bfmcommIroIro<Float>::comm (int result_cb, Fermion_t psi,int dag)
{
comm_start(result_cb,psi,dag);
comm_complete(result_cb,psi);
}
void wfm::dslash(Float *chi,
Float *u,
Float *psi,
int cb,
int dag)
{
/*
* To a first approximation, we simply
* remap the arguments into a form acceptable
* to the assembler, then call it
*/
/*
*Pull in the first Psi to cache early
*/
cache_touch(psi);
cache_touch(psi+4);
cache_touch(psi+8);
cache_touch(psi+12);
cache_touch(psi+16);
cache_touch(psi+20);
decom(psi,u,cb,dag);
#ifdef DEBUG_BENCHMARK_COMMS
double ndata = 2*2*allbound * 12 * TwoSpinSize() * 1.0E-6 * 100;
struct timeval start,stop,delta;
gettimeofday(&start,NULL);
for(int i=0;i<100;i++) {
#endif
comm_start(cb);
/*
* Hackers: you could split here and do something else...
* Such as DWF fith dimension, or a clover term etc...
* Might as well pull in a few sites worth of pointer table
* while we're waiting for the comms
*/
comm_complete(cb);
#ifdef DEBUG_BENCHMARK_COMMS
}
gettimeofday(&stop,NULL);
timersub(&stop,&start,&delta);
double seconds = delta.tv_usec * 1.0E-6 + delta.tv_sec;
if ( isBoss() ) printf("Comms %le MB in %le seconds = %le MB/s\n",ndata,seconds,ndata/seconds);
ndata = 2*2*allbound * 12 * TwoSpinSize() ;
if ( isBoss() ) printf("ndata = %d \n",ndata);
#endif
#ifdef DEBUG_OUTPUT_VECTORS
static int file_cnt;
{
char buf[256];
sprintf(buf,"2spin.%d.%d",UniqueID(),file_cnt);
FILE *fp = fopen(buf,"w");
for(int i=0;i<vol;i++) {
for(int pm=0;pm<2;pm++){
for(int mu=0;mu<4;mu++){
int offset = interleave_site(pm,mu,i);
for(int s=0;s<2;s++){
for(int c=0;c<3;c++){
for(int r=0;r<2;r++){
int scri;
if ( WFM_BGL ) scri = r + s*6+c*2;
else scri = r + s*2+c*4;
int gbl[4];
site_to_global(cb, i, gbl, local_latt );
if ( SloppyPrecision ) {
float * pointer = (float *) two_spinor;
fprintf(fp,"%d %d %d %d %d %d %d %d %d %e\n",gbl[0],gbl[1],gbl[2],gbl[3],
pm,mu,s,c,r,pointer[PAD_HALF_SPINOR_SIZE*offset+scri]);
} else {
Float * pointer = (Float *) two_spinor;
fprintf(fp,"%d %d %d %d %d %d %d %d %d %e\n",gbl[0],gbl[1],gbl[2],gbl[3],
pm,mu,s,c,r,pointer[PAD_HALF_SPINOR_SIZE*offset+scri]);
}
}}}
}
}
}
fclose(fp);}
#endif
cache_touch(two_spinor);
cache_touch(two_spinor+4);
cache_touch(two_spinor+8);
recon(chi,u,cb,dag);
#ifdef DEBUG_OUTPUT_VECTORS
{
char buf[256];
sprintf(buf,"recon.%d.%d",UniqueID(),file_cnt++);
FILE *fp = fopen(buf,"w");
for(int i=0;i<vol;i++) {
for(int pm=0;pm<2;pm++){
for(int mu=0;mu<4;mu++){
int offset = interleave_site(pm,mu,i);
for(int s=0;s<4;s++){
for(int c=0;c<3;c++){
for(int r=0;r<2;r++){
int scri;
scri = r + s*6+c*2;
Float * pointer = (Float *) chi;
int gbl[4];
site_to_global(cb, i, gbl, local_latt );
fprintf(fp,"%d %d %d %d %d %d %d %d %d %d %e\n",gbl[0],gbl[1],gbl[2],gbl[3],
i,pm,mu,s,c,r,pointer[SPINOR_SIZE*offset+scri]);
}}}
}
}
}
fclose(fp);}
exit(0);
#endif
return;
}
int main (void)
{
// Short circuit test
/*
DDRB |= (1 << 6) | (1 << 7); // LEDS
DDRD = (1<<7) | (1<<6); // ROMSEL, R/W
PORTD = (1<<7) | (1<<6); // ROMSEL, R/W
while(1)
{
int i;
for (i = 0; i < 8; i++)
{
DDRA = 0;
PORTA = 0xFF;
DDRF = 0;
PORTF = 0xFF;
PORTA &= ~(1<<i);
DDRA |= 1<<i;
LED_RED_OFF;
LED_GREEN_OFF;
_delay_ms(500);
if ((PINA != PORTA) || (PINF != PORTF))
{
LED_RED_ON;
} else {
LED_GREEN_ON;
}
_delay_ms(500);
}
for (i = 0; i < 8; i++)
{
DDRA = 0;
PORTA = 0xFF;
DDRF = 0;
PORTF = 0xFF;
PORTF &= ~(1<<i);
DDRF |= 1<<i;
LED_RED_OFF;
LED_GREEN_OFF;
_delay_ms(500);
if ((PINA != PORTA) || (PINF != PORTF))
{
LED_RED_ON;
} else {
LED_GREEN_ON;
}
_delay_ms(500);
}
}
*/
/*
DDRB |= (1 << 6) | (1 << 7); // LEDS
DDRD = (1<<7) | (1<<6); // ROMSEL, R/W
PORTD = (1<<7) | (1<<6); // ROMSEL, R/W
while(1)
{
int i;
for (i = 0; i < 8; i++)
{
DDRC = 0;
PORTC = 0xFF;
PORTC &= ~(1<<i);
DDRC |= 1<<i;
LED_RED_OFF;
LED_GREEN_OFF;
_delay_ms(500);
if ((PINC != PORTC))
{
LED_RED_ON;
} else {
LED_GREEN_ON;
}
_delay_ms(500);
}
}
*/
sei();
USART_init();
USART_init2();
#ifdef UPDATE_CHR_MODULE
unsigned int bd = (F_CPU / (16UL * 19200UL)) - 1;
UBRR0L = bd & 0xFF;
UBRR0H = bd >> 8;
UBRR1L = bd & 0xFF;
UBRR1H = bd >> 8;
LED_RED_ON;
LED_GREEN_ON;
while(1) { }
#endif
init_ports();
LED_RED_OFF;
LED_GREEN_OFF;
// MMC1 test
/*
set_address(0x8000);
PHI2_LOW;
MODE_WRITE;
PORTC = 0;
while (1)
{
LED_GREEN_OFF;
ROMSEL_HI;
_delay_ms(200);
LED_GREEN_ON;
ROMSEL_LOW;
_delay_ms(200);
}
*/
/*
write_prg_byte(0x8000, 0x80);
write_prg_byte(0x8000, 0);
write_prg_byte(0x8000, 0);
write_prg_byte(0x8000, 1);
write_prg_byte(0x8000, 1);
write_prg_byte(0x8000, 0);
write_prg_byte(0xe000, 0);
write_prg_byte(0xe000, 0);
write_prg_byte(0xe000, 0);
write_prg_byte(0xe000, 0);
write_prg_byte(0xe000, 0);
_delay_ms(500);
MODE_READ;
//set_address(0x8000);
PORTA = 0;
while(1);
*/
comm_init();
comm_start(COMMAND_PRG_STARTED, 0);
uint16_t address;
uint16_t length;
unsigned long int t = 0;
char led_down = 0;
int led_bright = 0;
while (1)
{
TCCR1A |= (1<<COM1C1) | (1<<COM1B1) | (1<<WGM10);
TCCR1B |= (1<<CS10);
if (t++ >= 10000)
{
if (!led_down)
{
led_bright++;
if (led_bright >= 110) led_down = 1;
} else {
led_bright--;
if (!led_bright) led_down = 0;
}
if (led_bright >= 100) OCR1B = led_bright - 100;
if (led_down)
{
int led_bright2 = 110-led_bright;
if (led_bright2 <= 20)
{
if (led_bright2 > 10) led_bright2 = 20 - led_bright2;
OCR1C = led_bright2*2;
}
}
t = 0;
}
if (comm_recv_done)
{
t = led_down = led_bright = 0;
TCCR1A = OCR1B = OCR1C = 0;
switch (comm_recv_command)
{
case COMMAND_PRG_INIT:
comm_start(COMMAND_PRG_STARTED, 0);
break;
case COMMAND_PRG_READ_REQUEST:
address = recv_buffer[0] | ((uint16_t)recv_buffer[1]<<8);
length = recv_buffer[2] | ((uint16_t)recv_buffer[3]<<8);
read_prg_send(address, length);
break;
case COMMAND_PRG_WRITE_REQUEST:
address = recv_buffer[0] | ((uint16_t)recv_buffer[1]<<8);
length = recv_buffer[2] | ((uint16_t)recv_buffer[3]<<8);
write_prg(address, length, (uint8_t*)&recv_buffer[4]);
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
case COMMAND_PHI2_INIT:
phi2_init();
comm_start(COMMAND_PHI2_INIT_DONE, 0);
break;
case COMMAND_RESET:
reset_phi2();
comm_start(COMMAND_RESET_ACK, 0);
break;
case COMMAND_EPROM_PREPARE:
write_eprom_prepare();
break;
case COMMAND_PRG_EPROM_WRITE_REQUEST:
address = recv_buffer[0] | ((uint16_t)recv_buffer[1]<<8);
length = recv_buffer[2] | ((uint16_t)recv_buffer[3]<<8);
write_eprom(address, length, (uint8_t*)&recv_buffer[4]);
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
case COMMAND_PRG_FLASH_ERASE_REQUEST:
if (erase_flash())
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
case COMMAND_PRG_FLASH_WRITE_REQUEST:
address = recv_buffer[0] | ((uint16_t)recv_buffer[1]<<8);
length = recv_buffer[2] | ((uint16_t)recv_buffer[3]<<8);
if (write_flash(address, length, (uint8_t*)&recv_buffer[4]))
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
case COMMAND_COOLGIRL_ERASE_SECTOR_REQUEST:
if (erase_coolgirl_sector())
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
case COMMAND_COOLGIRL_WRITE_REQUEST:
address = recv_buffer[0] | ((uint16_t)recv_buffer[1]<<8);
length = recv_buffer[2] | ((uint16_t)recv_buffer[3]<<8);
if (write_coolgirl(address, length, (uint8_t*)&recv_buffer[4]))
comm_start(COMMAND_PRG_WRITE_DONE, 0);
break;
}
comm_recv_done = 0;
}
}
}
