/*
 * Copyright 2019 Rockchip Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#include <cstdio>
#include <sys/mman.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>

#include "drm.h"
#include "drm_mode.h"
#include "drm_helper.h"
#include "logger/log.h"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "drm_helper"

static const char *DRM_DEV_NAME = "/dev/dri/card0";

int32_t drm_open() {
    int32_t fd = open(DRM_DEV_NAME, O_RDWR);
    if (fd < 0) {
        LOG_ERROR("fail to open drm device(%s)\n", DRM_DEV_NAME);
    }

    return fd;
}

int32_t drm_close(int32_t fd) {
    int32_t ret = close(fd);
    if (ret < 0) {
        return -errno;
    }

    return ret;
}

int32_t drm_get_phys(int32_t fd, uint32_t  handle, uint32_t  *phy, uint32_t  heaps) {
    /* no physical address */
    if (heaps != ROCKCHIP_BO_SECURE || heaps != ROCKCHIP_BO_CONTIG) {
        *phy = 0;
        return 0;
    }

    struct drm_rockchip_gem_phys phys_arg;
    phys_arg.handle = handle;
    int32_t ret = drm_ioctl(fd, DRM_IOCTL_ROCKCHIP_GEM_GET_PHYS, &phys_arg);
    if (ret < 0) {
        LOG_ERROR("fail to get phys(fd = %d), error: %s\n", fd, strerror(errno));
        return ret;
    } else {
        *phy = phys_arg.phy_addr;
    }
    return ret;
}

int32_t drm_ioctl(int32_t fd, int32_t req, void* arg) {
    int32_t ret = ioctl(fd, req, arg);
    if (ret < 0) {
        LOG_ERROR("fail to drm_ioctl(fd = %d, req =%d), error: %s\n", fd, req, strerror(errno));
        return -errno;
    }
    return ret;
}

int32_t drm_handle_to_fd(int32_t fd, uint32_t  handle, int32_t *map_fd, uint32_t flags) {
    int32_t ret;
    struct drm_prime_handle dph;
    memset(&dph, 0, sizeof(struct drm_prime_handle));
    dph.handle = handle;
    dph.fd = -1;
    dph.flags = flags;

    if (map_fd == NULL)
        return -EINVAL;

    ret = drm_ioctl(fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &dph);
    if (ret < 0) {
        return ret;
    }

    *map_fd = dph.fd;

    if (*map_fd < 0) {
        LOG_ERROR("fail to handle_to_fd(fd=%d)\n", fd);
        return -EINVAL;
    }

    return ret;
}

int32_t drm_fd_to_handle(
        int32_t fd,
        int32_t map_fd,
        uint32_t  *handle,
        uint32_t  flags) {
    int32_t ret;
    struct drm_prime_handle dph;

    dph.fd = map_fd;
    dph.flags = flags;

    ret = drm_ioctl(fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &dph);
    if (ret < 0) {
        return ret;
    }

    *handle = dph.handle;
    return ret;
}

int32_t drm_get_info_from_name(
        int32_t   fd,
        uint32_t   name,
        uint32_t  *handle,
        int32_t  *size) {
    int32_t  ret = 0;
    struct drm_gem_open req;

    req.name = name;
    ret = drm_ioctl(fd, DRM_IOCTL_GEM_OPEN, &req);
    if (ret < 0) {
        return ret;
    }

    *handle = req.handle;
    *size   = (int32_t)req.size;

    return ret;
}

int32_t drm_get_name_from_handle(int32_t fd, uint32_t handle, int32_t *name) {
    struct drm_gem_flink req;
    int32_t ret = 0;

    req.handle = handle,
    ret = drm_ioctl(fd, DRM_IOCTL_GEM_FLINK, &req);

    *name = req.name;
    return ret;
}

int32_t drm_alloc(
        int32_t fd,
        uint32_t  len,
        uint32_t  align,
        uint32_t  *handle,
        uint32_t  flags,
        uint32_t  heaps) {
    (void)flags;
    int32_t ret;
    struct drm_mode_create_dumb dmcb;

    memset(&dmcb, 0, sizeof(struct drm_mode_create_dumb));
    dmcb.bpp = 8;
    dmcb.width = (len + align - 1) & (~(align - 1));
    dmcb.height = 1;
    dmcb.flags = heaps;

    if (handle == NULL) {
        LOG_ERROR("illegal parameter, handler is null\n");
        return -EINVAL;
    }

    ret = drm_ioctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &dmcb);
    if (ret < 0) {
        return ret;
    }

    *handle = dmcb.handle;
    return ret;
}

int32_t drm_free(int32_t fd, uint32_t  handle) {
    struct drm_mode_destroy_dumb data = {
        .handle = handle,
    };
    return drm_ioctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &data);
}

#if 1
#include <errno.h> /* for EINVAL */

inline void *drm_mmap(void *addr, uint32_t  length, int32_t prot, int32_t flags,
                             int32_t fd, loff32_t offset) {
    /* offset must be aligned to 4096 (not necessarily the page size) */
    if (offset & 4095) {
        errno = EINVAL;
        return MAP_FAILED;
    }

    return mmap64(addr, length, prot, flags, fd, offset);
}

#define drm_munmap(addr, length) \
              munmap(addr, length)

#else

/* assume large file support exists */
#  define drm_mmap(addr, length, prot, flags, fd, offset) \
              mmap(addr, length, prot, flags, fd, offset)

#  define drm_munmap(addr, length) \
              munmap(addr, length)

#endif

int32_t drm_map(int32_t fd, int32_t handle, uint32_t  length, int32_t prot,
                   int32_t flags, int32_t offset, void **ptr, uint32_t  heaps) {
    int32_t ret;
    static uint32_t  pagesize_mask = 0;
    (void)offset;

    if (fd <= 0)
        return -EINVAL;
    if (ptr == NULL)
        return -EINVAL;

    if (!pagesize_mask)
        pagesize_mask = sysconf(_SC_PAGESIZE) - 1;

    length = (length + pagesize_mask) & ~pagesize_mask;

    struct drm_mode_map_dumb dmmd;

    memset(&dmmd, 0, sizeof(dmmd));
    dmmd.handle = (uint32_t )handle;

    ret = drm_ioctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &dmmd);
    if (ret) {
        LOG_ERROR("map_dumb failed: %s\n", strerror(ret));
        return ret;
    }

    *ptr = drm_mmap(NULL, length, prot, flags, fd, dmmd.offset);
    if (*ptr == MAP_FAILED) {
        if (heaps == ROCKCHIP_BO_SECURE) {
            LOG_ERROR("fail to drm_mmap(fd = %d), without physical address\n", fd);
            ret = 0;
        } else {
            LOG_ERROR("fail to drm_mmap(fd = %d), error: %s\n", fd, strerror(errno));
            ret = -errno;
        }
    }

    return ret;
}