#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

#include <poll.h>

#include <signal.h>

#include <sys/types.h>

#include <unistd.h>

#include <fcntl.h>

#include <time.h>

#include <pthread.h>

#include <sys/prctl.h>

#include <sys/syscall.h>

#include <sys/ioctl.h>

#include "IFMS_MemCMA_API.h"

int fd;

unsigned int handle_count = ;

volatile unsigned int dmatest_exit = ;

volatile sigio_received = ;

#define LOOP_COUNT 10000

#define DMA_MEMCPY    0

#define DMA_FILE "/dev/dpeye1000_axidma"

#define DPEYE1000_AXIDMA_IOC_MAGIC  'd'

#define DPEYE1000_AXIDMA_REQUEST_CHNN   _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 1, int)    //Request channel.

#define DPEYE1000_AXIDMA_RELEASE_CHNN   _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 2, int)    //Release channel.

#define DPEYE1000_AXIDMA_MEMCPY         _IOW(DPEYE1000_AXIDMA_IOC_MAGIC, 3, int)    //Do 1d memcpy.

//#define PERFORMANCE_DEBUG

struct axidma_dma

{

    struct dma_chan *chan;

    unsigned long    src;

    unsigned long    dst;

    // for memcpy

    unsigned int      len;

    unsigned int    n_channels;

};

struct thread_para

{

    unsigned int size;

    unsigned int expries;

    struct cma_block cma_block1;

    struct cma_block cma_block2;

};

static struct axidma_dma axidma_dma;

struct thread_para t_para;

int dmacopy_tid = ;

void trigger_dma_copy(void)

{

    int ret;

    #ifdef PERFORMANCE_DEBUG

    struct timespec time_0, time_1;

    unsigned long duration;

    float throughput = 0.0;

    clock_gettime(CLOCK_REALTIME, &time_0);

    #endif

    axidma_dma.src = (unsigned long)t_para.cma_block1.addr_p;

    axidma_dma.dst = (unsigned long)t_para.cma_block2.addr_p;

    axidma_dma.len = t_para.size;

    ret = ioctl(fd, DPEYE1000_AXIDMA_MEMCPY, &axidma_dma);

    if(ret < )

    {

        printf("fail to ioctl DPEYE1000_AXIDMA_MEMCPY!!!\n");

    }

    #ifdef PERFORMANCE_DEBUG

    clock_gettime(CLOCK_REALTIME, &time_1);

    duration = (time_1.tv_sec-time_0.tv_sec)* + (time_1.tv_nsec-time_0.tv_nsec);

    throughput = (float)t_para.size/*/duration;

    printf("%ld.%ld %d %d, %ld, %f\n", time_1.tv_sec, time_1.tv_nsec, handle_count, t_para.size, duration, throughput);

    #endif

}

void sigint_handler(int sig)

{

    if(sig == SIGINT)

    {

        printf("%s SIGINT\n", __func__);

        dmatest_exit = ;

    }

}

void sigio_handler(int sig)

{

    if(sig == SIGIO)

    {

        sigio_received = ;

    }

}

static void pthread_func(void *arg)

{

    int ret;

    int Oflags;

    struct f_owner_ex owner_ex;

    struct timespec time1, time2;

    struct sigaction sa, sa2;

    sigset_t set, oldset;

    long long duration;

    unsigned int mode = DMA_MEMCPY;

    ret = IFMS_MemCMAAlloc(t_para.size, &t_para.cma_block1);

    if(ret<)

    {

        printf("CMA alloc failed.\n");

        return -;

    }

    ret=IFMS_MemCMAAlloc(t_para.size, &t_para.cma_block2);

    if(ret<)

    {

        printf("CMA alloc failed.\n");

        return -;

    }

//===========================================================================================

//Set thread name.

    prctl(PR_SET_NAME,"sigio");

    dmacopy_tid = syscall(SYS_gettid);

    printf("sigio thread tid=%ld %ld.\n", syscall(SYS_gettid), getpid());

//Set SIGIO actiong.

    memset(&sa, , sizeof(sa));

    sa.sa_handler = sigio_handler;

    sa.sa_flags |= SA_RESTART;

    sigaction(SIGIO, &sa, NULL);

//Set proc mask.

    sigemptyset(&set);

    sigprocmask(SIG_SETMASK, &set, NULL);

    sigaddset(&set, SIGIO);

    fd = open(DMA_FILE, O_RDWR);

    if (fd < )

    {

        printf("Can't open %s!\n", DMA_FILE);

    }

    //If set F_SETOWN_EX, SIGIO will send to this thread only.

    owner_ex.pid = syscall(SYS_gettid);

    owner_ex.type = F_OWNER_TID;

    fcntl(fd, F_SETOWN_EX, &owner_ex);

    Oflags = fcntl(fd, F_GETFL);

    fcntl(fd, F_SETFL, Oflags | FASYNC);

    clock_gettime(CLOCK_REALTIME, &time1);

    ret = ioctl(fd, DPEYE1000_AXIDMA_REQUEST_CHNN, &mode);

    if(ret < )

    {

        printf("fail to ioctl DPEYE1000_AXIDMA_REQUEST_CHNN!!!\n");

    }

    while(!dmatest_exit)

    {

        if(t_para.expries > )

            usleep(t_para.expries);

        trigger_dma_copy();     //Send DMA copy request.        while(!sigio_received)

        while(!sigio_received)

        {

            pthread_sigmask(SIG_BLOCK, &set, &oldset);

            //sigprocmask(SIG_BLOCK, &set, &oldset);

            sigsuspend(&oldset);    //Will pause here, and will be waked up by SIGIO.

            pthread_sigmask(SIG_UNBLOCK, &set, NULL);

            //sigprocmask(SIG_UNBLOCK, &set, NULL);

            handle_count++;

        }

        sigio_received = ;

    }

    clock_gettime(CLOCK_REALTIME, &time2);

    duration = (long long)(time2.tv_sec-time1.tv_sec)* + (time2.tv_nsec-time1.tv_nsec);

    sleep();

    printf("End time %lld.%09lld count=%d fps=%lld.\n", duration/, duration%, handle_count, (long long)handle_count*/duration);

    ioctl(fd, DPEYE1000_AXIDMA_RELEASE_CHNN, NULL);

    if(ret < )

    {

        printf("fail to ioctl DPEYE1000_AXIDMA_RELEASE_CHNN!!!\n");

    }

    close(fd);

//===========================================================================================

    ret=IFMS_MemCMAFree(t_para.cma_block1);

    if(ret<)

    {

        printf("CMA free failed.\n");

        return -;

    }

    ret=IFMS_MemCMAFree(t_para.cma_block2);

    if(ret<)

    {

        printf("CMA free failed.\n");

        return -;

    }

    pthread_exit();

}

void main(int argc, char **argv)

{

    pthread_t tidp;

    sigset_t set;

    unsigned int size = , expries = ;

    struct sigaction sa;

    if(argc != )

    {

        printf("Usage: %s size(B) expries(us).\n", argv[]);

        return -;

    }

    size = atoi(argv[]);

    if(!size)

    {

        printf("Please input right size.\n");

        return -;

    }

    expries = atoi(argv[]);

    if(!expries)

    {

        printf("Please input right expries time.\n");

        return -;

    }

    t_para.size = size;

    t_para.expries = expries;

    memset(&sa, , sizeof(sa));

    sa.sa_handler = sigint_handler;

    sa.sa_flags |= SA_RESTART;

    sigaction(SIGINT, &sa, NULL);

    sigemptyset(&set);

    sigaddset(&set, SIGIO);

    sigprocmask(SIG_BLOCK, &set, NULL);

    if(pthread_create(&tidp, NULL, pthread_func, NULL) == -)

    {

        printf("Create pthread error.\n");

        return;

    }

    if(pthread_join(tidp, NULL))

    {

        printf("Join pthread error.\n");

        return;

    }

    printf("Main exit.\n");

    return;

}