DmaDriver.h

Go to the documentation of this file.

 
#ifndef __DMA_DRIVER_H__
#define __DMA_DRIVER_H__
 
#ifdef DMA_IN_KERNEL
    #include <linux/types.h>
#else
    #include <stdint.h>
 
    #include <string>
#endif
 
/* API Version */
#define DMA_VERSION 0x06
 
/* Error values */
#define DMA_ERR_FIFO 0x01
#define DMA_ERR_LEN  0x02
#define DMA_ERR_MAX  0x04
#define DMA_ERR_BUS  0x08
 
/* Commands */
 
#define DMA_Get_Buff_Count           0x1001
 
#define DMA_Get_Buff_Size            0x1002
 
#define DMA_Set_Debug                0x1003
 
#define DMA_Set_Mask                 0x1004
 
#define DMA_Ret_Index                0x1005
 
#define DMA_Get_Index                0x1006
 
#define DMA_Read_Ready               0x1007
 
#define DMA_Set_MaskBytes            0x1008
 
#define DMA_Get_Version              0x1009
 
#define DMA_Write_Register           0x100A
 
#define DMA_Read_Register            0x100B
 
#define DMA_Get_RxBuff_Count         0x100C
 
#define DMA_Get_TxBuff_Count         0x100D
 
#define DMA_Get_TxBuffinUser_Count   0x100F
 
#define DMA_Get_TxBuffinHW_Count     0x1010
 
#define DMA_Get_TxBuffinPreHWQ_Count 0x1011
 
#define DMA_Get_TxBuffinSWQ_Count    0x1012
 
#define DMA_Get_TxBuffMiss_Count     0x1013
 
#define DMA_Get_RxBuffinUser_Count   0x1014
 
#define DMA_Get_RxBuffinHW_Count     0x1015
 
#define DMA_Get_RxBuffinPreHWQ_Count 0x1016
 
#define DMA_Get_RxBuffinSWQ_Count    0x1017
 
#define DMA_Get_RxBuffMiss_Count     0x1018
 
#define DMA_Get_GITV                 0x1019
 
/* Mask size */
#define DMA_MASK_SIZE 512
 
struct DmaWriteData {
    uint64_t data;
    uint32_t dest;
    uint32_t flags;
    uint32_t index;
    uint32_t size;
    uint32_t is32;
    uint32_t pad;
};
 
struct DmaReadData {
    uint64_t data;
    uint32_t dest;
    uint32_t flags;
    uint32_t index;
    uint32_t error;
    uint32_t size;
    uint32_t is32;
    int32_t ret;
};
 
struct DmaRegisterData {
    uint64_t address;
    uint32_t data;
};
 
// Conditional inclusion for non-kernel environments
#ifndef DMA_IN_KERNEL
    #include <signal.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/fcntl.h>
    #include <sys/ioctl.h>
    #include <sys/mman.h>
    #include <sys/signal.h>
    #include <sys/socket.h>
    #include <unistd.h>
 
static inline ssize_t dmaWrite(int32_t fd, const void* buf, size_t size, uint32_t flags, uint32_t dest) {
    struct DmaWriteData w;
 
    memset(&w, 0, sizeof(struct DmaWriteData));
    w.dest  = dest;
    w.flags = flags;
    w.size  = size;
    w.is32  = (sizeof(void*) == 4);
    w.data  = (uint64_t)buf;//NOLINT
 
    return (write(fd, &w, sizeof(struct DmaWriteData)));
}
 
static inline ssize_t dmaWriteIndex(int32_t fd, uint32_t index, size_t size, uint32_t flags, uint32_t dest) {
    struct DmaWriteData w;
 
    memset(&w, 0, sizeof(struct DmaWriteData));
    w.dest  = dest;
    w.flags = flags;
    w.size  = size;
    w.is32  = (sizeof(void*) == 4);
    w.index = index;
 
    return (write(fd, &w, sizeof(struct DmaWriteData)));
}
 
static inline ssize_t dmaWriteVector(int32_t fd,
                                     struct iovec* iov,
                                     size_t iovlen,
                                     uint32_t begFlags,
                                     uint32_t midFlags,
                                     uint32_t endFlags,
                                     uint32_t dest) {
    uint32_t x;
    ssize_t ret;
    ssize_t res;
    struct DmaWriteData w;
 
    ret = 0;
 
    for (x = 0; x < iovlen; x++) {
        memset(&w, 0, sizeof(struct DmaWriteData));
        w.dest  = dest;
        w.flags = (x == 0) ? begFlags : ((x == (iovlen - 1)) ? endFlags : midFlags);
        w.size  = iov[x].iov_len;
        w.is32  = (sizeof(void*) == 4);
        w.data  = (uint64_t)iov[x].iov_base;//NOLINT
 
        do {
            res = write(fd, &w, sizeof(struct DmaWriteData));
 
            if (res < 0)
                return (res);
            else if (res == 0)
                usleep(10);
            else
                ret += res;
        } while (res == 0);
    }
    return (ret);
}
 
static inline ssize_t dmaWriteIndexVector(int32_t fd,
                                          struct iovec* iov,
                                          size_t iovlen,
                                          uint32_t begFlags,
                                          uint32_t midFlags,
                                          uint32_t endFlags,
                                          uint32_t dest) {
    uint32_t x;
    ssize_t ret;
    ssize_t res;
    struct DmaWriteData w;
 
    ret = 0;
 
    for (x = 0; x < iovlen; x++) {
        memset(&w, 0, sizeof(struct DmaWriteData));
        w.dest  = dest;
        w.flags = (x == 0) ? begFlags : ((x == (iovlen - 1)) ? endFlags : midFlags);
        w.size  = iov[x].iov_len;
        w.is32  = (sizeof(void*) == 4);
        w.index = (uint32_t)(((uint64_t)iov[x].iov_base) & 0xFFFFFFFF);//NOLINT
 
        do {
            res = write(fd, &w, sizeof(struct DmaWriteData));
 
            if (res < 0)
                return (res);
            else if (res == 0)
                usleep(10);
            else
                ret += res;
        } while (res == 0);
    }
    return (ret);
}
 
static inline ssize_t dmaRead(int32_t fd, void* buf, size_t maxSize, uint32_t* flags, uint32_t* error, uint32_t* dest) {
    struct DmaReadData r;
    ssize_t ret;
 
    memset(&r, 0, sizeof(struct DmaReadData));
    r.size = maxSize;
    r.is32 = (sizeof(void*) == 4);
    r.data = (uint64_t)buf;//NOLINT
 
    ret = read(fd, &r, sizeof(struct DmaReadData));
 
    if (ret <= 0) return (ret);
 
    if (dest != NULL) *dest = r.dest;
    if (flags != NULL) *flags = r.flags;
    if (error != NULL) *error = r.error;
 
    return (r.ret);
}
 
static inline ssize_t dmaReadIndex(int32_t fd, uint32_t* index, uint32_t* flags, uint32_t* error, uint32_t* dest) {
    struct DmaReadData r;
    ssize_t ret;
 
    memset(&r, 0, sizeof(struct DmaReadData));
 
    ret = read(fd, &r, sizeof(struct DmaReadData));
 
    if (ret <= 0) return (ret);
 
    if (dest != NULL) *dest = r.dest;
    if (flags != NULL) *flags = r.flags;
    if (error != NULL) *error = r.error;
 
    *index = r.index;
    return (r.ret);
}
 
static inline ssize_t dmaReadBulkIndex(int32_t fd,
                                       uint32_t count,
                                       int32_t* ret,
                                       uint32_t* index,
                                       uint32_t* flags,
                                       uint32_t* error,
                                       uint32_t* dest) {
    struct DmaReadData r[count];
    ssize_t res;
    ssize_t x;
 
    memset(r, 0, count * sizeof(struct DmaReadData));
 
    res = read(fd, r, count * sizeof(struct DmaReadData));
 
    for (x = 0; x < res; ++x) {
        if (dest != NULL) dest[x] = r[x].dest;
        if (flags != NULL) flags[x] = r[x].flags;
        if (error != NULL) error[x] = r[x].error;
 
        index[x] = r[x].index;
        ret[x]   = r[x].ret;
    }
    return (res);
}
 
static inline ssize_t dmaRetIndex(int32_t fd, uint32_t index) {
    uint32_t cmd = DMA_Ret_Index | 0x10000;
 
    return (ioctl(fd, cmd, &index));
}
 
static inline ssize_t dmaRetIndexes(int32_t fd, uint32_t count, uint32_t* indexes) {
    uint32_t cmd = DMA_Ret_Index | ((count << 16) & 0xFFFF0000);
 
    return (ioctl(fd, cmd, indexes));
}
 
static inline int32_t dmaGetIndex(int32_t fd) {
    return (ioctl(fd, DMA_Get_Index, 0));
}
 
static inline ssize_t dmaReadReady(int32_t fd) {
    return (ioctl(fd, DMA_Read_Ready, 0));
}
 
static inline ssize_t dmaGetRxBuffCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuff_Count, 0));
}
 
static inline ssize_t dmaGetRxBuffinUserCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuffinUser_Count, 0));
}
 
static inline ssize_t dmaGetRxBuffinHwCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuffinHW_Count, 0));
}
 
static inline ssize_t dmaGetRxBuffinPreHwQCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuffinPreHWQ_Count, 0));
}
 
static inline ssize_t dmaGetRxBuffinSwQCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuffinSWQ_Count, 0));
}
 
static inline ssize_t dmaGetRxBuffMissCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_RxBuffMiss_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuff_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffinUserCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuffinUser_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffinHwCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuffinHW_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffinPreHwQCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuffinPreHWQ_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffinSwQCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuffinSWQ_Count, 0));
}
 
static inline ssize_t dmaGetTxBuffMissCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_TxBuffMiss_Count, 0));
}
 
static inline ssize_t dmaGetBuffSize(int32_t fd) {
    return (ioctl(fd, DMA_Get_Buff_Size, 0));
}
 
static inline ssize_t dmaGetBuffCount(int32_t fd) {
    return (ioctl(fd, DMA_Get_Buff_Count, 0));
}
 
static inline std::string dmaGetGitVersion(int32_t fd) {
    char gitv[32] = {0};  // Initialize with zeros to ensure null-termination
    if (ioctl(fd, DMA_Get_GITV, gitv) < 0) {
        return "";
    }
    gitv[32 - 1] = '\0';  // Ensure null-termination
    return std::string(gitv);
}
 
static inline void** dmaMapDma(int32_t fd, uint32_t* count, uint32_t* size) {
    void* temp;
    void** ret;
    uint32_t bCount;
    uint32_t gCount;
    uint32_t bSize;
    off_t offset;
 
    bSize  = ioctl(fd, DMA_Get_Buff_Size, 0);
    bCount = ioctl(fd, DMA_Get_Buff_Count, 0);
 
    if (count != NULL) *count = bCount;
    if (size != NULL) *size = bSize;
 
    if ((ret = reinterpret_cast<void**>(calloc(sizeof(void*), bCount))) == 0) return (NULL);
 
    // Attempt to map
    gCount = 0;
    while (gCount < bCount) {
        offset = (off_t)bSize * (off_t)gCount;
 
        if ((temp = mmap(0, bSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset)) == MAP_FAILED) break;
        ret[gCount++] = temp;
    }
 
    // Map failed
    if (gCount != bCount) {
        while (gCount != 0) munmap(ret[--gCount], bSize);
        free(ret);
        ret = NULL;
    }
    return (ret);
}
 
static inline ssize_t dmaUnMapDma(int32_t fd, void** buffer) {
    uint32_t bCount;
    uint32_t bSize;
    uint32_t x;
 
    bCount = ioctl(fd, DMA_Get_Buff_Count, 0);
    bSize  = ioctl(fd, DMA_Get_Buff_Size, 0);
 
    for (x = 0; x < bCount; x++) munmap(buffer[x], bSize);
 
    free(buffer);
    return (0);
}
 
static inline ssize_t dmaSetDebug(int32_t fd, uint32_t level) {
    return (ioctl(fd, DMA_Set_Debug, level));
}
 
static inline void dmaAssignHandler(int32_t fd, void (*handler)(int32_t)) {
    struct sigaction act;
    int32_t oflags;
 
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
 
    sigaction(SIGIO, &act, NULL);
    fcntl(fd, F_SETOWN, getpid());
    oflags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, oflags | FASYNC);
}
 
static inline ssize_t dmaSetMask(int32_t fd, uint32_t mask) {
    return (ioctl(fd, DMA_Set_Mask, mask));
}
 
static inline void dmaInitMaskBytes(uint8_t* mask) {
    memset(mask, 0, DMA_MASK_SIZE);
}
 
static inline void dmaAddMaskBytes(uint8_t* mask, uint32_t dest) {
    uint32_t byte;
    uint32_t bit;
 
    if (dest < 8 * (DMA_MASK_SIZE)) {
        byte = dest / 8;
        bit  = dest % 8;
        mask[byte] += (1 << bit);
    }
}
 
static inline ssize_t dmaSetMaskBytes(int32_t fd, uint8_t* mask) {
    return (ioctl(fd, DMA_Set_MaskBytes, mask));
}
 
static inline ssize_t dmaCheckVersion(int32_t fd) {
    int32_t version;
    version = ioctl(fd, DMA_Get_Version);
    return ((version == DMA_VERSION) ? 0 : -1);
}
 
static inline ssize_t dmaGetApiVersion(int32_t fd) {
    return (ioctl(fd, DMA_Get_Version, 0));
}
 
static inline ssize_t dmaWriteRegister(int32_t fd, uint64_t address, uint32_t data) {
    struct DmaRegisterData reg;
 
    reg.address = address;
    reg.data    = data;
    return (ioctl(fd, DMA_Write_Register, &reg));
}
 
static inline ssize_t dmaReadRegister(int32_t fd, uint64_t address, uint32_t* data) {
    struct DmaRegisterData reg;
    ssize_t res;
 
    // Initialize register data structure
    reg.address = address;
    reg.data    = 0;
 
    // Perform ioctl to read the register
    res = ioctl(fd, DMA_Read_Register, &reg);
 
    // If data pointer is valid, update it with the read value
    if (data != NULL) *data = reg.data;
 
    return res;
}
 
static inline void* dmaMapRegister(int32_t fd, off_t offset, uint32_t size) {
    uint32_t bSize;
    uint32_t bCount;
    off_t intOffset;
 
    // Obtain buffer size and count from the DMA device
    bSize  = ioctl(fd, DMA_Get_Buff_Size, 0);
    bCount = ioctl(fd, DMA_Get_Buff_Count, 0);
 
    // Calculate internal offset
    intOffset = ((off_t)bSize * bCount) + offset;
 
    // Attempt to map the memory region into user space
    return mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, intOffset);
}
 
static inline ssize_t dmaUnMapRegister(int32_t fd, void* ptr, uint32_t size) {
    // Unmap the memory region
    munmap(ptr, size);
    return 0;
}
 
#endif  // !DMA_IN_KERNEL
#endif  // __DMA_DRIVER_H__