/*
 * drm_device.cpp - DRM Device Implementation
 *
 *  Copyright (c) 2021 Rockchip Corporation
 *
 * 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 "drm_device.h"

#include <fcntl.h>
#include <sys/mman.h>
#include <xf86drm.h>

#include <string>

#include "xcam_common.h"
#include "xcam_log.h"

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

static inline int drm_munmap(void* addr, size_t length) {
    /* Copied from configure code generated by AC_SYS_LARGEFILE */
#define LARGE_OFF_T ((((off_t)1 << 31) << 31) - 1 + (((off_t)1 << 31) << 31))
    static_assert(LARGE_OFF_T % 2147483629 == 721 &&
                  LARGE_OFF_T % 2147483647 == 1);
#undef LARGE_OFF_T
    return munmap(addr, length);
}
}

namespace XCam {

DrmDevice::DrmDevice() : fd_(Open()) {}

DrmDevice::~DrmDevice() = default;

int DrmDevice::Open() {
    std::string devName(DRM_DIR_NAME);
    uint64_t has_dumb = 0;
    int fd;

    devName.append("/card");
    devName.append(std::to_string(0));
    fd = drmOpen("rockchip", devName.c_str());
    if (fd < 0) {
        LOGE("Failed to open DRM module rockchip");
        return -1;
    }

    drmVersionPtr version = drmGetVersion(fd);
    if (version == nullptr) {
        LOGE("Failed to get DRM version");
        ::close(fd);
        return -1;
    }
    LOGI("Opened DRM device %s: driver %s version V%d.%d.%d", devName.c_str(),
         version->name, version->version_major, version->version_minor,
         version->version_patchlevel);
    drmFreeVersion(version);

    if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 || !has_dumb) {
        LOGE("DRM device does not support dumb buffer");
        ::close(fd);
        return -1;
    }

    return fd;
}

void DrmDevice::Close() {
    if (fd_.Get() >= 0) {
        drmClose(fd_.Get());
    }
}

bool DrmDevice::Available() { return !!drmAvailable(); }

std::unique_ptr<DrmDumbObject> DrmDevice::CreateDumbObject(
    unsigned int width, unsigned int height, unsigned int bpp,
    unsigned int num_planes) {
    struct drm_mode_create_dumb arg;
    int ret;
    // @cody TODO: use make_unique if use C++ > C++14
    std::unique_ptr<DrmDumbObject> bo =
        std::unique_ptr<DrmDumbObject>(new DrmDumbObject());

    memset(&arg, 0, sizeof(arg));
    arg.bpp    = bpp;
    arg.width  = width;
    arg.height = height;

    bo->num_planes = num_planes;
    for (unsigned int plane = 0; plane < num_planes; plane++) {
        ret = drmIoctl(fd_.Get(), DRM_IOCTL_MODE_CREATE_DUMB, &arg);
        if (ret) {
            LOGE("failed to create dumb buffer: %s", strerror(errno));
            return nullptr;
        }

        ret = drmPrimeHandleToFD(fd_.Get(), arg.handle, DRM_CLOEXEC | DRM_RDWR,
                                 &bo->fds[plane]);
        if (ret) {
            LOGE("failed to create dumb buffer: %s", strerror(errno));
            return nullptr;
        }
        assert(bo->fds[plane] >= 0);

        bo->handles[plane] = arg.handle;
        bo->sizes[plane]   = arg.size;
        bo->strides[plane] = arg.pitch;
    }

    return bo;
}

XCamReturn DrmDevice::DestroyDumbObject(
    const std::unique_ptr<DrmDumbObject>& bo) {
    struct drm_mode_destroy_dumb arg;
    int ret;

    assert(fd_.Get() >= 0);

    memset(&arg, 0, sizeof(arg));
    for (int plane = 0; plane < bo->num_planes; plane++) {
        if (bo->handles[plane] == 0) {
            continue;
        }
        arg.handle = bo->handles[plane];

        ret = drmIoctl(fd_.Get(), DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
        if (ret) {
            LOGE("failed to destroy dumb buffer: %s", strerror(errno));
            // return XCAM_RETURN_ERROR_FAILED;
        }
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn DrmDevice::RequestMapDumbObject(
    const std::unique_ptr<DrmDumbObject>& bo, unsigned int plane) {
    struct drm_mode_map_dumb arg;
    void* map;
    int ret;

    assert(fd_.Get() >= 0);

    memset(&arg, 0, sizeof(arg));
    arg.handle = bo->handles[plane];
    ret        = drmIoctl(fd_.Get(), DRM_IOCTL_MODE_MAP_DUMB, &arg);
    if (ret) {
        LOGE("drm ioctrl failed map %s", strerror(errno));
        return XCAM_RETURN_ERROR_FAILED;
    }

    return XCAM_RETURN_NO_ERROR;
}

}  // namespace RkCam