Data Transfer from FPGA-to-HPS

Hi Eugene,

Just a few questions on your code.

On this section here:

if(!source_empty && !mm_bridge_2_s0_waitrequest)			begin
			mm_bridge_2_s0_read<=1;
			mm_bridge_2_s0_address<=fifo_read_offset|{5'b0,fifo_read_address};
			fifo_read_address<=fifo_read_address+4;
			source_empty<=...;
			end
		else if(!mm_bridge_2_s0_waitrequest)
			mm_bridge_2_s0_read<=0;
		if(mm_bridge_2_s0_readdatavalid && !core_full)
			... <= mm_bridge_2_s0_readdata;
		else
			mm_bridge_2_s0_read<=0;

I am pretty lost on what this read section here is for. I don't think I need to do any reads so for now I am commenting it out assuming that it is regarding some specific act you are trying to do. I'm not exactly sure. And I do not know what source_empty or core_full are either.

I am pretty sure I understand the write section found here:

if(core_readdatavalid & !mm_bridge_0_s0_waitrequest)			begin
			mm_bridge_0_s0_write<=1;
			mm_bridge_0_s0_writedata <= data_input;
			mm_bridge_0_s0_address<=fifo_write_offset|{5'b0,fifo_write_address};
			fifo_write_address<=fifo_write_address+4;
			end
		else if(!mm_bridge_0_s0_waitrequest)
			mm_bridge_0_s0_write<=0;

Except I am not sure what core_readdatavalid is for, I'm assuming though that it would help if I understood what the read section before that is for?

Given that I followed along with everything above correctly, I modified it into my module here:

module send_to_hps(data_input, mm_bridge_0_s0_waitrequest, mm_bridge_0_s0_writedata, mm_bridge_0_s0_address, mm_bridge_0_s0_write);
	//Inputs
	input  data_input;
	input mm_bridge_0_s0_waitrequest;
	
	//Wires
	//wire mm_bridge_0_s0_waitrequest;
	//wire  mm_bridge_0_s0_readdata;
	//wire        mm_bridge_0_s0_readdatavalid;
	
	//Outputs
	output  mm_bridge_0_s0_writedata;
	output mm_bridge_0_s0_write;
	output mm_bridge_0_s0_address;
	
	//Registers
	reg  mm_bridge_0_s0_writedata=0;
	reg  mm_bridge_0_s0_address=0;
	reg mm_bridge_0_s0_write=0;
	//reg mm_bridge_0_s0_read=0;
	//reg fifo_read_offset= 32'h20000000;
	//reg fifo_read_address=0;
	reg fifo_write_offset=32'h28000000;
	reg fifo_write_address=0;
	/*if(!source_empty && !mm_bridge_2_s0_waitrequest)
			begin
			mm_bridge_2_s0_read<=1;
			mm_bridge_2_s0_address<=fifo_read_offset|{5'b0,fifo_read_address};
			fifo_read_address<=fifo_read_address+4;
			source_empty<=...;
			end
		else if(!mm_bridge_2_s0_waitrequest)
			mm_bridge_2_s0_read<=0;
		if(mm_bridge_2_s0_readdatavalid && !core_full)
			... <= mm_bridge_2_s0_readdata;
		else
			mm_bridge_2_s0_read<=0;*/
	always @ (data_input)
	begin
		if(/*core_readdatavalid &&*/ !mm_bridge_0_s0_waitrequest)
			begin
			mm_bridge_0_s0_write<=1;
			mm_bridge_0_s0_writedata <= data_input;
			mm_bridge_0_s0_address<=fifo_write_offset|{5'b0,fifo_write_address};
			fifo_write_address<=fifo_write_address+16;
			end
		else if(!mm_bridge_0_s0_waitrequest)
			mm_bridge_0_s0_write<=0;
	end
endmodule

The Inputs/Outputs to this module are all connected to the MM_Bridge for the HPS except for data_input. So I think that's correct.

I have two final questions:

One where did you come to the address 32'h28000000 to start writing at?

And two would I then try to read from that address in Linux using the C code something like this:

char* toBinary(int value, int precision){	static char buf = {0};
	buf = 0;
  for(; value && precision ; --precision, value /= 2)	{
    buf = "01";		
  }
  for(; precision ; --precision){
    buf = '0';
  }
	return &buf;
}
int main(int argc, char *argv) {
    if (argc != 3) {
        printf("usage: %s <address> <#bytes>\n",argv);
        return 0;
    }
    off_t offset = strtoul(argv, NULL, 0);
    size_t len = strtoul(argv, NULL, 0);
    // Truncate offset to a multiple of the page size, or mmap will fail.
    size_t pagesize = sysconf(_SC_PAGE_SIZE);
    off_t page_base = (offset / pagesize) * pagesize;
    off_t page_offset = offset - page_base;
    int fd = open("/dev/mem", O_SYNC);
    unsigned char *mem = mmap(NULL, page_offset + len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, page_base);
    if (mem == MAP_FAILED) {
        perror("Can't map memory");
        return -1;
    }
    size_t i;
    for (i = 0; i < len; i++){
        int temp = (int)mem; 
        printf("%s ",toBinary(temp,8));
        if((i + 1) % 16 == 0 && i != len - 1){
            printf("\n");
        }
    }
    printf("\n");
    for (i = 0; i < len; i++){
        int temp = (int)mem; 
        if(temp >= 32 && temp <= 126){
            printf("%c",temp);
        }else{
            printf("_");
        }
        if((i + 1) % 143 == 0 && i != len - 1){
            printf("\n");
        }
    }
    printf("\n");
    
    return 0;
}

Where address would be 28000000 and bytes in my case would be 16 for 128 bits?