/*
 * dma_buffer.cpp - DMA Buffer Implementation
 *
 *  Copyright (c) 2021 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.
 *
 * Author: Cody Xie <cody.xie@rock-chips.com>
 */
#include "dma_buffer.h"

#include <fcntl.h>
#include <linux/dma-buf.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

#include <cassert>

#include "xcam_log.h"
#include "xcam_std.h"

namespace XCam {

DmaBuffer::DmaBuffer(int fd, size_t size) : fd_(fd), size_(size), ptr_(nullptr) {}

DmaBuffer::~DmaBuffer() {
    if (ptr_ != nullptr) {
        unmap();
    }
}

XCamReturn DmaBuffer::sync(int fd, DmaBufferDirection direction, bool start) {
    int ret;
    struct dma_buf_sync sync = {0};

    XCAM_ASSERT(fd >= 0);

    if (direction == DmaBufferDirection::kDeviceToCPU) {
        sync.flags = DMA_BUF_SYNC_READ;
    } else if (direction == DmaBufferDirection::kCPUToDevice) {
        sync.flags = DMA_BUF_SYNC_WRITE;
    } else {
        sync.flags = DMA_BUF_SYNC_RW;
    }

    if (start) {
        sync.flags |= DMA_BUF_SYNC_START;
    } else {
        sync.flags |= DMA_BUF_SYNC_END;
    }

    ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
    if (ret) {
        LOGE("DMA_BUF_IOCTL_SYNC ioctl failed %s", strerror(errno));
        return XCAM_RETURN_ERROR_IOCTL;
    }

    LOGI("%s CPU access dir %d for BO fd %d", start ? "start" : "end", direction, fd);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn DmaBuffer::beginCpuAccess(DmaBufferDirection direction) {
    XCAM_ASSERT(ptr_ != nullptr);
    return sync(fd_.Get(), direction, true);
}

XCamReturn DmaBuffer::endCpuAccess(DmaBufferDirection direction) {
    XCAM_ASSERT(ptr_ != nullptr);
    return sync(fd_.Get(), direction, false);
}

void* DmaBuffer::map() {
    int ret;

    assert(((void)"could not map invalid dma_buf", fd_.Get() > 0 && ptr_ == nullptr && size_ > 0));

    ptr_ = mmap(0, size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_.Get(), 0);
    if (ptr_ == MAP_FAILED) {
        LOGE("dma_buf map failed %s", strerror(errno));
        return nullptr;
    }

    return ptr_;
}

void DmaBuffer::unmap() {
    assert(((void)"unmap dma_buf in wrong state", fd_.Get() > 0 && ptr_ != nullptr));

    munmap(ptr_, size_);
    ptr_ = nullptr;
}

int DmaBuffer::getFd() { return fd_.Get(); }

size_t DmaBuffer::getSize() { return size_; }

int DmaBuffer::release() { return fd_.Release(); }

bool DmaBuffer::mapped() { return ptr_ == nullptr ? false : true; }

}  // namespace XCam