/*
 * Copyright (c) 2012 Xilinx, Inc.  All rights reserved.
 *
 * Xilinx, Inc.
 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
 * COURTESY TO YOU.  BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
 * ONE POSSIBLE   IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
 * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
 * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
 * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
 * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
 * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
 * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
 * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>

#define DMA_BASEADDR 0x40400000
#define S2MM_DMACR 0xC
#define S2MM_DMASR 0xD
#define S2MM_DA 0x12
#define S2MM_LENGTH 0x16
#define COUNTER_BASEADDR_gpio_0 0x41200000
#define COUNTER_BASEADDR_gpio_1 0x41210000
#define DEST_ADDR 0x00aa0000
#define PAGE_SIZE 0x1fff
/*typedef struct {
char data[32];
}byte;*/

void start_transfer(volatile unsigned int *dma_virt_addr, unsigned int bytes)
	{

	*(dma_virt_addr + S2MM_LENGTH) = bytes;
	unsigned int reg = *(dma_virt_addr + S2MM_LENGTH);
	printf("\nDMA length\n:0x%08x ", reg);
	printf("\n address of DMA length reg\n:0x%08x ", (dma_virt_addr + S2MM_LENGTH));
	if ((*(dma_virt_addr+S2MM_DMASR) & (0x1<<12)) == 0)
	{
		printf("\nTransfer complete\n");
	}
	}

int counter_config(volatile unsigned int *counter_virt_addr_gpio_0 ,volatile unsigned int *counter_virt_addr_gpio_1)
	{
	unsigned int reg=0,reg_1=0;

	*counter_virt_addr_gpio_0 = 0x0;
	reg = *counter_virt_addr_gpio_0;
	printf("\nCounter reg address value:0x%08x\n", counter_virt_addr_gpio_0);
	reg = 0x0FF;
	printf("\nCounter reg value:0x%08x\n", reg);
	*counter_virt_addr_gpio_0 = reg;

	reg=0;
	reg = *(counter_virt_addr_gpio_0);
	printf("\nCounter reg:0x%08x\n", reg);
	printf("\nCounter reg:0x%08x\n", *(counter_virt_addr_gpio_0));

	*counter_virt_addr_gpio_1 = 0x0;
	reg_1 = *counter_virt_addr_gpio_1;
	printf("\nCounter reg address value:0x%08x\n",counter_virt_addr_gpio_1);
	reg_1 = 0x1;
	printf("\nCounter reg value1:0x%08x\n", reg_1);
	*counter_virt_addr_gpio_1 = reg_1;

	reg_1=0;
	reg_1 = *(counter_virt_addr_gpio_1);
	printf("\nCounter reg:0x%08x\n", reg_1);
	return 0;
}

int dma_config(volatile unsigned int *dma_virt_addr, unsigned int dest_addr)
	{
	unsigned int reg=0;

	*(dma_virt_addr + S2MM_DMACR) = 0;
	printf("\n address of\n DMA_CR:0x%08x\n", (dma_virt_addr + S2MM_DMACR));
	reg = *(dma_virt_addr + S2MM_DMACR);
	printf("\n befotre DMA engine started\n DMA_CR:0x%08x\n", reg);
	*(dma_virt_addr + S2MM_DMACR) |= 0x1;

	reg=0;
	reg = *(dma_virt_addr + S2MM_DMACR);
	printf("\nDMA engine started\n DMA_CR:0x%08x\n", reg);

	while((*(dma_virt_addr + S2MM_DMASR)) & 0x1);
	{
	*(dma_virt_addr + S2MM_DA) = dest_addr;
	printf("\n address of\n DMA_DA:0x%08x\n", (dma_virt_addr + S2MM_DA));
	//printf("\nDest_addr:0x%08x\n", reg);
	}

	reg=0;
	reg = *(dma_virt_addr + S2MM_DA);
	printf("\nDest_addr:0x%08x\n", reg);

	return 0;
	}

int main()
{

	int fd=0 , reg=0, reg_0=0 , reg_1=0 , reg_2=0 , i=0 , j=0;
	volatile unsigned int *counter_virt_addr_gpio_0=NULL, *counter_virt_addr_gpio_1=NULL,*dma_virt_addr=NULL;
	unsigned int *buff_virt_addr=NULL, *data=NULL;
	char buffer[500];
	//byte *int_val;

	if ( (fd = open("/dev/mem", O_RDWR|O_SYNC)) < 1) // open the /dev/mem device file
	{
	perror("\nError opening device file\n");
	return -1;
	}
	fprintf(stdout, "\nOpened device file successfully\n");
    printf("Hello World\n");

    dma_virt_addr = (volatile unsigned int*)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, DMA_BASEADDR);

    reg = dma_virt_addr;
    printf("\ndma virt add:0x%08x\n", reg);

    if (dma_virt_addr == NULL)
    	perror("\nUnable fetch virt. addr. for AXI DMA\n");
    else
    	printf("dma maps good");

    counter_virt_addr_gpio_0 = (volatile unsigned int*)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, COUNTER_BASEADDR_gpio_0);

    reg_0 = counter_virt_addr_gpio_0;
    printf("\n gpio_0 virt add:0x%08x\n", reg_0);

    if (counter_virt_addr_gpio_0 == NULL)
    	perror("\nUnable fetch virt. addr. for AXI Counter\n");
    else
       	printf("gpio_0 maps good");

    counter_virt_addr_gpio_1 = (volatile unsigned int*)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, COUNTER_BASEADDR_gpio_1);

    reg_1 = counter_virt_addr_gpio_1;
    printf("\n gpio_1 virt add:0x%08x\n", reg_1);

    if (counter_virt_addr_gpio_1 == NULL)
    	perror("\nUnable fetch virt. addr. for AXI Counter\n");
    else
        printf("gpio_1 maps good");

    buff_virt_addr = (unsigned int*)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, DEST_ADDR);

    reg_2 = buff_virt_addr;
    printf("\n buffer virt add:0x%08x\n", reg_2);

    if (buff_virt_addr == NULL)
    	perror("\n Unable fetch virt. addr. for AXI DMA buffer\n");
    else
        printf("buffer maps good");

    dma_config(dma_virt_addr,DEST_ADDR);
    counter_config(counter_virt_addr_gpio_0,counter_virt_addr_gpio_1);
    start_transfer(dma_virt_addr, 256);

    //memset(buff_virt_addr, 0, 256);

   // start_transfer(dma_virt_addr, 256);
    //memcpy(buffer, buff_virt_addr, 256);

    //int_val = (byte*)data;

   for (i=0; i<256; i++) {
   // for(j=31; j>=0; j--)
    printf("\nData:0x%02x\n", *(buff_virt_addr+i));
    }

    munmap((void*)buff_virt_addr, PAGE_SIZE);
    munmap((void*)counter_virt_addr_gpio_0, PAGE_SIZE);
    munmap((void*)counter_virt_addr_gpio_1, PAGE_SIZE);
    munmap((void*)dma_virt_addr, PAGE_SIZE);

    free(data);
    close(fd);
    return 0;
}