/*
 * Copyright (c) 2022 Rockchip Electronics Co. Ltd.
 */
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <xf86drm.h>
#include <rockchip_drm.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>

#include "rkcrypto_mem.h"
#include "rkcrypto_trace.h"
#include "rk_list.h"
#include "dma-heap.h"

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
#endif

#define DRM_MODULE_NAME "rockchip"
#define DRM_CARD_PATH "/dev/dri/card0"
#define DMA_HEAP_PATH "/dev/rk_dma_heap/rk-dma-heap-cma"

#define IS_DMA_INVALID()	(dma_node_fd < 0)

struct mem_pool_node {
	rk_crypto_mem		mem;
	uint32_t		handle;
	uint32_t		flags;
	struct list_head	list;
};

struct mem_ops {
	int (*init)(void);
	void (*deinit)(int dma_node_fd);
	struct mem_pool_node *(*alloc_node)(int dma_node_fd, uint32_t size);
	void (*free_node)(int dma_node_fd, struct mem_pool_node *node);
};

static int dma_node_fd = -1;
static struct list_head mem_pool_list;
pthread_mutex_t dma_mutex = PTHREAD_MUTEX_INITIALIZER;
static int mem_init_cnt;
struct mem_ops *cur_mem_pos;

static int crypto_init_drm(void)
{
	int fd;

	fd = open(DRM_CARD_PATH, O_RDWR);
	if (fd < 0)
		D_TRACE("failed to open drm !\n");

	return fd;
}

static void crypto_deinit_drm(int dma_node_fd)
{
	if (dma_node_fd >= 0)
		close(dma_node_fd);
}

static struct mem_pool_node *crypto_alloc_node_drm(int dma_node_fd, uint32_t size)
{
	int ret = -1;
	size_t min_size;
	struct mem_pool_node *node = NULL;
	struct drm_rockchip_gem_create req = {
		.size = size,
		.flags = 1,
	};
	struct drm_rockchip_gem_map_off map_req;

	/* cma must alloc at least two page */
	min_size = 2 * getpagesize();
	req.size  = size < min_size ? min_size : size;

	node = malloc(sizeof(*node));
	if (!node)
		return NULL;

	memset(node, 0x00, sizeof(*node));
	memset(&map_req, 0x00, sizeof(map_req));

	ret = drmIoctl(dma_node_fd, DRM_IOCTL_ROCKCHIP_GEM_CREATE, &req);
	if (ret) {
		free(node);
		return NULL;
	}

	ret = drmPrimeHandleToFD(dma_node_fd, req.handle, 0, &node->mem.dma_fd);
	if (ret) {
		E_TRACE("failed to get dma dma_node_fd.\n");
		goto error;
	}

	map_req.handle = req.handle;
	ret = drmIoctl(dma_node_fd, DRM_IOCTL_ROCKCHIP_GEM_MAP_OFFSET, &map_req);
	if (ret) {
		E_TRACE("failed to ioctl gem map offset.");
		goto error;
	}

	D_TRACE("handle = %u, dma_fd = %d, alloc_size = %u, real_size = %u\n",
		req.handle, node->mem.dma_fd, size, req.size);

#ifdef __ANDROID__
	node->mem.vaddr = mmap64(0, req.size, PROT_READ | PROT_WRITE, MAP_SHARED,
				 dma_node_fd, map_req.offset);
#else
	node->mem.vaddr = mmap(0, req.size, PROT_READ | PROT_WRITE, MAP_SHARED,
			       dma_node_fd, map_req.offset);
#endif
	if (node->mem.vaddr == MAP_FAILED) {
		E_TRACE("failed to mmap buffer. offset = %"PRIu64", reason: %s\n",
			map_req.offset, strerror(errno));
		ret = -1;
		goto error;
	}

	node->handle   = req.handle;
	node->flags    = req.flags;
	node->mem.size = size;

	return node;
error:
	drmIoctl(dma_node_fd, DRM_IOCTL_GEM_CLOSE, &req);

	if (node)
		free(node);

	return NULL;
}

static void crypto_free_node_drm(int dma_node_fd, struct mem_pool_node *node)
{
	struct drm_gem_close req;
	size_t min_size;
	min_size = 2 * getpagesize();

	if (!node || node->mem.size == 0)
		return;

	memset(&req, 0x00, sizeof(req));

	req.handle = node->handle;

	if (node->mem.vaddr)
		munmap(node->mem.vaddr, node->mem.size < min_size ? min_size : node->mem.size);

	if (node->mem.dma_fd >= 0)
		close(node->mem.dma_fd);

	drmIoctl(dma_node_fd, DRM_IOCTL_GEM_CLOSE, &req);

	free(node);
}

static int crypto_init_dma_heap(void)
{
	int fd;

	fd = open(DMA_HEAP_PATH, O_RDWR);
	if (fd < 0)
		D_TRACE("failed to open cma heap !\n");

	return fd;
}

static void crypto_deinit_dma_heap(int dma_node_fd)
{
	if (dma_node_fd >= 0)
		close(dma_node_fd);
}

static struct mem_pool_node *crypto_alloc_node_dma_heap(int dma_node_fd, uint32_t size)
{
	int ret = -1;
	size_t min_size;
	struct mem_pool_node *node = NULL;
	struct dma_heap_allocation_data req = {
		.len = size,
		.fd_flags = O_CLOEXEC | O_RDWR,
	};

	/* cma must alloc at least two page */
	min_size = 2 * getpagesize();
	req.len  = size < min_size ? min_size : size;

	node = malloc(sizeof(*node));
	if (!node)
		return NULL;

	memset(node, 0x00, sizeof(*node));

	req.fd = 0;
	ret = ioctl(dma_node_fd, DMA_HEAP_IOCTL_ALLOC, &req);
	if (ret < 0) {
		E_TRACE("DMA_HEAP_ALLOC_BUFFER failed\n");
		free(node);
		return NULL;
	}

	node->mem.dma_fd = req.fd;

	D_TRACE("dma_fd = %d, alloc_size = %u, real_size = %u\n",
		node->mem.dma_fd, size, req.len);

#ifdef __ANDROID__
	node->mem.vaddr = mmap64(0, req.len, PROT_READ | PROT_WRITE, MAP_SHARED, req.fd, 0);
#else
	node->mem.vaddr = mmap(0, req.len, PROT_READ | PROT_WRITE, MAP_SHARED, req.fd, 0);
#endif
	if (node->mem.vaddr == MAP_FAILED) {
		E_TRACE("failed to mmap buffer. fd = %"PRIu64", reason: %s\n",
			req.fd, strerror(errno));
		ret = -1;
		goto error;
	}

	node->flags    = req.fd_flags;
	node->mem.size = size;

	return node;
error:
	close(req.fd);

	if (node)
		free(node);

	return NULL;
}

static void crypto_free_node_dma_heap(int dma_node_fd, struct mem_pool_node *node)
{
	size_t min_size;

	min_size = 2 * getpagesize();

	if (!node || node->mem.size == 0)
		return;

	if (node->mem.vaddr)
		munmap(node->mem.vaddr, node->mem.size < min_size ? min_size : node->mem.size);

	if (node->mem.dma_fd >= 0)
		close(node->mem.dma_fd);

	free(node);
}

struct mem_ops rk_mem_ops_tbl[] = {
	{
		.init       = crypto_init_dma_heap,
		.deinit     = crypto_deinit_dma_heap,
		.alloc_node = crypto_alloc_node_dma_heap,
		.free_node  = crypto_free_node_dma_heap,
	},
	{
		.init       = crypto_init_drm,
		.deinit     = crypto_deinit_drm,
		.alloc_node = crypto_alloc_node_drm,
		.free_node  = crypto_free_node_drm,
	},
};

int rk_crypto_mem_init(void)
{
	int ret = -1;
	uint32_t i;

	if (mem_init_cnt > 0) {
		ret = 0;
		return ret;
	}

	pthread_mutex_lock(&dma_mutex);

	INIT_LIST_HEAD(&mem_pool_list);

	for (i = 0; i < ARRAY_SIZE(rk_mem_ops_tbl); i++) {
		dma_node_fd = rk_mem_ops_tbl[i].init();
		if (dma_node_fd >= 0)
			break;
	}

	if (dma_node_fd < 0) {
		ret = -1;
		goto exit;
	}

	cur_mem_pos = &rk_mem_ops_tbl[i];

	mem_init_cnt++;

	ret = 0;
exit:
	pthread_mutex_unlock(&dma_mutex);

	return ret;
}

void rk_crypto_mem_deinit(void)
{
	/* free list */
	struct mem_pool_node *node;
	struct list_head *pos, *n;

	pthread_mutex_lock(&dma_mutex);

	mem_init_cnt--;
	if (mem_init_cnt > 0)
		goto exit;

	if (IS_DMA_INVALID())
		goto exit;

	list_for_each_safe(pos, n, &mem_pool_list) {
		node = list_entry(pos, struct mem_pool_node, list);
		list_del(pos);

		if (cur_mem_pos)
			cur_mem_pos->free_node(dma_node_fd, node);
	}

	if (cur_mem_pos)
		cur_mem_pos->deinit(dma_node_fd);
exit:
	pthread_mutex_unlock(&dma_mutex);
}

rk_crypto_mem *rk_crypto_mem_alloc(size_t size)
{
	struct mem_pool_node *node;

	pthread_mutex_lock(&dma_mutex);

	if (IS_DMA_INVALID() || !cur_mem_pos)
		goto error;

	node = cur_mem_pos->alloc_node(dma_node_fd, size);
	if (!node)
		goto error;

	list_add_tail(&node->list, &mem_pool_list);

	pthread_mutex_unlock(&dma_mutex);

	return &node->mem;
error:
	pthread_mutex_unlock(&dma_mutex);

	return NULL;
}

void rk_crypto_mem_free(rk_crypto_mem *memory)
{
	struct mem_pool_node *node;
	struct list_head *pos, *n;

	pthread_mutex_lock(&dma_mutex);

	if (IS_DMA_INVALID() || !cur_mem_pos)
		goto exit;

	if (!memory)
		goto exit;

	list_for_each_safe(pos, n, &mem_pool_list) {
		node = list_entry(pos, struct mem_pool_node, list);

		if (&node->mem == memory) {
			list_del(pos);
			cur_mem_pos->free_node(dma_node_fd, node);
			goto exit;
		}
	}

exit:
	pthread_mutex_unlock(&dma_mutex);
}