// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) Rockchip Electronics Co., Ltd.
 *
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

#define pr_fmt(fmt) "rga: " fmt

#include "rga2_reg_info.h"
#include "rga3_reg_info.h"
#include "rga_dma_buf.h"
#include "rga_mm.h"

#include "rga_job.h"
#include "rga_fence.h"
#include "rga_hw_config.h"

#include "rga_iommu.h"
#include "rga_debugger.h"
#include "rga_common.h"

struct rga_drvdata_t *rga_drvdata;

/* set hrtimer */
static struct hrtimer timer;
static ktime_t kt;

static struct rga_session *rga_session_init(void);
static int rga_session_deinit(struct rga_session *session);

static int rga_mpi_set_channel_buffer(struct dma_buf *dma_buf,
				      struct rga_img_info_t *channel_info,
				      struct rga_session *session)
{
	struct rga_external_buffer buffer;

	memset(&buffer, 0x0, sizeof(buffer));
	buffer.memory = (unsigned long)dma_buf;
	buffer.type = RGA_DMA_BUFFER_PTR;
	buffer.memory_parm.width = channel_info->vir_w;
	buffer.memory_parm.height = channel_info->vir_h;
	buffer.memory_parm.format = channel_info->format;

	buffer.handle = rga_mm_import_buffer(&buffer, session);
	if (buffer.handle == 0) {
		pr_err("can not import dma_buf %p\n", dma_buf);
		return -EFAULT;
	}
	channel_info->yrgb_addr = buffer.handle;

	return 0;
}

static void rga_mpi_set_channel_info(uint32_t flags_mask, uint32_t flags,
				     struct rga_video_frame_info *mpi_frame,
				     struct rga_img_info_t *channel_info,
				     struct rga_img_info_t *cache_info)
{
	uint32_t fix_enable_flag, cache_info_flag;

	switch (flags_mask) {
	case RGA_CONTEXT_SRC_MASK:
		fix_enable_flag = RGA_CONTEXT_SRC_FIX_ENABLE;
		cache_info_flag = RGA_CONTEXT_SRC_CACHE_INFO;
		break;
	case RGA_CONTEXT_PAT_MASK:
		fix_enable_flag = RGA_CONTEXT_PAT_FIX_ENABLE;
		cache_info_flag = RGA_CONTEXT_PAT_CACHE_INFO;
		break;
	case RGA_CONTEXT_DST_MASK:
		fix_enable_flag = RGA_CONTEXT_DST_FIX_ENABLE;
		cache_info_flag = RGA_CONTEXT_DST_CACHE_INFO;
		break;
	default:
		return;
	}

	if (flags & fix_enable_flag) {
		channel_info->x_offset = mpi_frame->x_offset;
		channel_info->y_offset = mpi_frame->y_offset;
		channel_info->act_w = mpi_frame->width;
		channel_info->act_h = mpi_frame->height;
		channel_info->vir_w = mpi_frame->vir_w;
		channel_info->vir_h = mpi_frame->vir_h;
		channel_info->rd_mode = mpi_frame->rd_mode;
		channel_info->format = mpi_frame->format;

		if (flags & cache_info_flag) {
			/* Replace the config of src in ctx with the config of mpi src. */
			cache_info->x_offset = mpi_frame->x_offset;
			cache_info->y_offset = mpi_frame->y_offset;
			cache_info->act_w = mpi_frame->width;
			cache_info->act_h = mpi_frame->height;
			cache_info->vir_w = mpi_frame->vir_w;
			cache_info->vir_h = mpi_frame->vir_h;
			cache_info->rd_mode = mpi_frame->rd_mode;
			cache_info->format = mpi_frame->format;

		}
	}
}

int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
{
	int ret = 0;
	struct rga_pending_request_manager *request_manager;
	struct rga_request *request;
	struct rga_req *cached_cmd;
	struct rga_req mpi_cmd;
	unsigned long flags;

	request_manager = rga_drvdata->pend_request_manager;

	mutex_lock(&request_manager->lock);
	request = rga_request_lookup(request_manager, mpi_job->ctx_id);
	if (IS_ERR_OR_NULL(request)) {
		pr_err("can not find request from id[%d]", mpi_job->ctx_id);
		mutex_unlock(&request_manager->lock);
		return -EINVAL;
	}

	if (request->task_count > 1) {
		/* TODO */
		pr_err("Currently request does not support multiple tasks!");
		mutex_unlock(&request_manager->lock);
		return -EINVAL;
	}

	/*
	 * The mpi commit will use the request repeatedly, so an additional
	 * get() is added here.
	 */
	rga_request_get(request);
	mutex_unlock(&request_manager->lock);

	spin_lock_irqsave(&request->lock, flags);

	/* TODO: batch mode need mpi async mode */
	request->sync_mode = RGA_BLIT_SYNC;

	cached_cmd = request->task_list;
	memcpy(&mpi_cmd, cached_cmd, sizeof(mpi_cmd));

	spin_unlock_irqrestore(&request->lock, flags);

	/* set channel info */
	if ((mpi_job->src != NULL) && (request->flags & RGA_CONTEXT_SRC_MASK))
		rga_mpi_set_channel_info(RGA_CONTEXT_SRC_MASK,
					 request->flags,
					 mpi_job->src,
					 &mpi_cmd.src,
					 &cached_cmd->src);

	if ((mpi_job->pat != NULL) && (request->flags & RGA_CONTEXT_PAT_MASK))
		rga_mpi_set_channel_info(RGA_CONTEXT_PAT_MASK,
					 request->flags,
					 mpi_job->pat,
					 &mpi_cmd.pat,
					 &cached_cmd->pat);

	if ((mpi_job->dst != NULL) && (request->flags & RGA_CONTEXT_DST_MASK))
		rga_mpi_set_channel_info(RGA_CONTEXT_DST_MASK,
					 request->flags,
					 mpi_job->dst,
					 &mpi_cmd.dst,
					 &cached_cmd->dst);

	/* set buffer handle */
	if (mpi_job->dma_buf_src0 != NULL) {
		ret = rga_mpi_set_channel_buffer(mpi_job->dma_buf_src0,
						 &mpi_cmd.src,
						 request->session);
		if (ret < 0) {
			pr_err("src channel set buffer handle failed!\n");
			goto err_put_request;
		}
	}

	if (mpi_job->dma_buf_src1 != NULL) {
		ret = rga_mpi_set_channel_buffer(mpi_job->dma_buf_src1,
						 &mpi_cmd.pat,
						 request->session);
		if (ret < 0) {
			pr_err("src1 channel set buffer handle failed!\n");
			goto err_put_request;
		}
	}

	if (mpi_job->dma_buf_dst != NULL) {
		ret = rga_mpi_set_channel_buffer(mpi_job->dma_buf_dst,
						 &mpi_cmd.dst,
						 request->session);
		if (ret < 0) {
			pr_err("dst channel set buffer handle failed!\n");
			goto err_put_request;
		}
	}

	mpi_cmd.handle_flag = 1;
	mpi_cmd.mmu_info.mmu_en = 0;
	mpi_cmd.mmu_info.mmu_flag = 0;

	if (DEBUGGER_EN(MSG))
		rga_cmd_print_debug_info(&mpi_cmd);

	ret = rga_request_mpi_submit(&mpi_cmd, request);
	if (ret < 0) {
		if (ret == -ERESTARTSYS) {
			if (DEBUGGER_EN(MSG))
				pr_err("%s, commit mpi job failed, by a software interrupt.\n",
					__func__);
		} else {
			pr_err("%s, commit mpi job failed\n", __func__);
		}

		goto err_put_request;
	}

	if ((mpi_job->dma_buf_src0 != NULL) && (mpi_cmd.src.yrgb_addr > 0))
		rga_mm_release_buffer(mpi_cmd.src.yrgb_addr);
	if ((mpi_job->dma_buf_src1 != NULL) && (mpi_cmd.pat.yrgb_addr > 0))
		rga_mm_release_buffer(mpi_cmd.pat.yrgb_addr);
	if ((mpi_job->dma_buf_dst != NULL) && (mpi_cmd.dst.yrgb_addr > 0))
		rga_mm_release_buffer(mpi_cmd.dst.yrgb_addr);

	/* copy dst info to mpi job for next node */
	if (mpi_job->output != NULL) {
		mpi_job->output->x_offset = mpi_cmd.dst.x_offset;
		mpi_job->output->y_offset = mpi_cmd.dst.y_offset;
		mpi_job->output->width = mpi_cmd.dst.act_w;
		mpi_job->output->height = mpi_cmd.dst.act_h;
		mpi_job->output->vir_w = mpi_cmd.dst.vir_w;
		mpi_job->output->vir_h = mpi_cmd.dst.vir_h;
		mpi_job->output->rd_mode = mpi_cmd.dst.rd_mode;
		mpi_job->output->format = mpi_cmd.dst.format;
	}

	return 0;

err_put_request:
	mutex_lock(&request_manager->lock);
	rga_request_put(request);
	mutex_unlock(&request_manager->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(rga_mpi_commit);

int rga_kernel_commit(struct rga_req *cmd)
{
	int ret = 0;
	int request_id;
	struct rga_user_request kernel_request;
	struct rga_request *request = NULL;
	struct rga_session *session = NULL;
	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;

	session = rga_session_init();
	if (IS_ERR(session))
		return PTR_ERR(session);

	request_id = rga_request_alloc(0, session);
	if (request_id < 0) {
		pr_err("request alloc error!\n");
		ret = request_id;
		return ret;
	}

	memset(&kernel_request, 0, sizeof(kernel_request));
	kernel_request.id = request_id;
	kernel_request.task_ptr = (uint64_t)(unsigned long)cmd;
	kernel_request.task_num = 1;
	kernel_request.sync_mode = RGA_BLIT_SYNC;

	ret = rga_request_check(&kernel_request);
	if (ret < 0) {
		pr_err("user request check error!\n");
		goto err_free_request_by_id;
	}

	request = rga_request_kernel_config(&kernel_request);
	if (IS_ERR(request)) {
		pr_err("request[%d] config failed!\n", kernel_request.id);
		ret = -EFAULT;
		goto err_free_request_by_id;
	}

	if (DEBUGGER_EN(MSG)) {
		pr_info("kernel blit mode: request id = %d", kernel_request.id);
		rga_cmd_print_debug_info(cmd);
	}

	ret = rga_request_submit(request);
	if (ret < 0) {
		pr_err("request[%d] submit failed!\n", kernel_request.id);
		goto err_put_request;
	}

err_put_request:
	mutex_lock(&request_manager->lock);
	rga_request_put(request);
	mutex_unlock(&request_manager->lock);

	rga_session_deinit(session);

	return ret;

err_free_request_by_id:
	mutex_lock(&request_manager->lock);

	request = rga_request_lookup(request_manager, request_id);
	if (IS_ERR_OR_NULL(request)) {
		pr_err("can not find request from id[%d]", request_id);
		mutex_unlock(&request_manager->lock);
		return -EINVAL;
	}

	rga_request_free(request);

	mutex_unlock(&request_manager->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(rga_kernel_commit);

static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
{
	struct rga_drvdata_t *rga = rga_drvdata;
	struct rga_scheduler_t *scheduler = NULL;
	struct rga_job *job = NULL;
	unsigned long flags;
	int i;

	ktime_t now = ktime_get();

	for (i = 0; i < rga->num_of_scheduler; i++) {
		scheduler = rga->scheduler[i];

		spin_lock_irqsave(&scheduler->irq_lock, flags);

		/* if timer action on job running */
		job = scheduler->running_job;
		if (job) {
			scheduler->timer.busy_time += ktime_us_delta(now, job->hw_recoder_time);
			job->hw_recoder_time = now;
		}

		scheduler->timer.busy_time_record = scheduler->timer.busy_time;
		scheduler->timer.busy_time = 0;

		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
	}

	hrtimer_forward_now(timer, kt);
	return HRTIMER_RESTART;
}

static void rga_init_timer(void)
{
	kt = ktime_set(0, RGA_TIMER_INTERVAL_NS);
	hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

	timer.function = hrtimer_handler;

	hrtimer_start(&timer, kt, HRTIMER_MODE_REL);
}

static void rga_cancel_timer(void)
{
	hrtimer_cancel(&timer);
}

#ifndef RGA_DISABLE_PM
int rga_power_enable(struct rga_scheduler_t *scheduler)
{
	int ret = -EINVAL;
	int i;
	unsigned long flags;

	pm_runtime_get_sync(scheduler->dev);
	pm_stay_awake(scheduler->dev);

	for (i = 0; i < scheduler->num_clks; i++) {
		if (!IS_ERR(scheduler->clks[i])) {
			ret = clk_prepare_enable(scheduler->clks[i]);
			if (ret < 0)
				goto err_enable_clk;
		}
	}

	spin_lock_irqsave(&scheduler->irq_lock, flags);

	scheduler->pd_refcount++;
	if (scheduler->status == RGA_SCHEDULER_IDLE)
		scheduler->status = RGA_SCHEDULER_WORKING;

	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

	return 0;

err_enable_clk:
	for (--i; i >= 0; --i)
		if (!IS_ERR(scheduler->clks[i]))
			clk_disable_unprepare(scheduler->clks[i]);

	pm_relax(scheduler->dev);
	pm_runtime_put_sync_suspend(scheduler->dev);

	return ret;
}

int rga_power_disable(struct rga_scheduler_t *scheduler)
{
	int i;
	unsigned long flags;

	spin_lock_irqsave(&scheduler->irq_lock, flags);

	if (scheduler->status == RGA_SCHEDULER_IDLE ||
	    scheduler->pd_refcount == 0) {
		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
		WARN(true, "%s already idle!\n", dev_driver_string(scheduler->dev));
		return -1;
	}

	scheduler->pd_refcount--;
	if (scheduler->pd_refcount == 0)
		scheduler->status = RGA_SCHEDULER_IDLE;

	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

	for (i = scheduler->num_clks - 1; i >= 0; i--)
		if (!IS_ERR(scheduler->clks[i]))
			clk_disable_unprepare(scheduler->clks[i]);

	pm_relax(scheduler->dev);
	pm_runtime_put_sync_suspend(scheduler->dev);

	return 0;
}

static void rga_power_enable_all(void)
{
	struct rga_scheduler_t *scheduler = NULL;
	int ret = 0;
	int i;

	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
		scheduler = rga_drvdata->scheduler[i];
		ret = rga_power_enable(scheduler);
		if (ret < 0)
			pr_err("power enable failed");
	}
}

static void rga_power_disable_all(void)
{
	struct rga_scheduler_t *scheduler = NULL;
	int i;

	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
		scheduler = rga_drvdata->scheduler[i];
		rga_power_disable(scheduler);
	}
}

#else
int rga_power_enable(struct rga_scheduler_t *scheduler)
{
	return 0;
}

int rga_power_disable(struct rga_scheduler_t *scheduler)
{
	return 0;
}

static inline void rga_power_enable_all(void) {}
static inline void rga_power_disable_all(void) {}
#endif /* #ifndef RGA_DISABLE_PM */

static int rga_session_manager_init(struct rga_session_manager **session_manager_ptr)
{
	struct rga_session_manager *session_manager = NULL;

	*session_manager_ptr = kzalloc(sizeof(struct rga_session_manager), GFP_KERNEL);
	if (*session_manager_ptr == NULL) {
		pr_err("can not kzalloc for rga_session_manager\n");
		return -ENOMEM;
	}

	session_manager = *session_manager_ptr;

	mutex_init(&session_manager->lock);

	idr_init_base(&session_manager->ctx_id_idr, 1);

	return 0;
}

/*
 * Called at driver close to release the rga session's id references.
 */
static int rga_session_free_remove_idr_cb(int id, void *ptr, void *data)
{
	struct rga_session *session = ptr;

	idr_remove(&rga_drvdata->session_manager->ctx_id_idr, session->id);
	kfree(session);

	return 0;
}

static int rga_session_free_remove_idr(struct rga_session *session)
{
	struct rga_session_manager *session_manager;

	session_manager = rga_drvdata->session_manager;

	mutex_lock(&session_manager->lock);

	session_manager->session_cnt--;
	idr_remove(&session_manager->ctx_id_idr, session->id);

	mutex_unlock(&session_manager->lock);

	return 0;
}

static int rga_session_manager_remove(struct rga_session_manager **session_manager_ptr)
{
	struct rga_session_manager *session_manager = *session_manager_ptr;

	mutex_lock(&session_manager->lock);

	idr_for_each(&session_manager->ctx_id_idr, &rga_session_free_remove_idr_cb, session_manager);
	idr_destroy(&session_manager->ctx_id_idr);

	mutex_unlock(&session_manager->lock);

	kfree(*session_manager_ptr);

	*session_manager_ptr = NULL;

	return 0;
}

static struct rga_session *rga_session_init(void)
{
	int new_id;

	struct rga_session_manager *session_manager = NULL;
	struct rga_session *session = NULL;

	session_manager = rga_drvdata->session_manager;
	if (session_manager == NULL) {
		pr_err("rga_session_manager is null!\n");
		return ERR_PTR(-EFAULT);
	}

	session = kzalloc(sizeof(*session), GFP_KERNEL);
	if (!session) {
		pr_err("rga_session alloc failed\n");
		return ERR_PTR(-ENOMEM);
	}

	mutex_lock(&session_manager->lock);

	idr_preload(GFP_KERNEL);
	new_id = idr_alloc_cyclic(&session_manager->ctx_id_idr, session, 1, 0, GFP_NOWAIT);
	idr_preload_end();
	if (new_id < 0) {
		mutex_unlock(&session_manager->lock);

		pr_err("rga_session alloc id failed!\n");
		kfree(session);
		return ERR_PTR(new_id);
	}

	session->id = new_id;
	session_manager->session_cnt++;

	mutex_unlock(&session_manager->lock);

	session->tgid = current->tgid;
	session->pname = kstrdup_quotable_cmdline(current, GFP_KERNEL);

	return session;
}

static int rga_session_deinit(struct rga_session *session)
{
	rga_request_session_destroy_abort(session);
	rga_mm_session_release_buffer(session);

	rga_session_free_remove_idr(session);

	kfree(session->pname);
	kfree(session);

	return 0;
}

static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *session)
{
	int i;
	int ret = 0;
	struct rga_buffer_pool buffer_pool;
	struct rga_external_buffer *external_buffer = NULL;

	if (unlikely(copy_from_user(&buffer_pool,
				    (struct rga_buffer_pool *)arg,
				    sizeof(buffer_pool)))) {
		pr_err("rga_buffer_pool copy_from_user failed!\n");
		return -EFAULT;
	}

	if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
		pr_err("Cannot import more than %d buffers at a time!\n",
		       RGA_BUFFER_POOL_SIZE_MAX);
		return -EFBIG;
	}

	if (buffer_pool.buffers_ptr == 0) {
		pr_err("Import buffers is NULL!\n");
		return -EFAULT;
	}

	external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
				  GFP_KERNEL);
	if (external_buffer == NULL) {
		pr_err("external buffer list alloc error!\n");
		return -ENOMEM;
	}

	if (unlikely(copy_from_user(external_buffer,
				    u64_to_user_ptr(buffer_pool.buffers_ptr),
				    sizeof(struct rga_external_buffer) * buffer_pool.size))) {
		pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
		ret = -EFAULT;

		goto err_free_external_buffer;
	}

	for (i = 0; i < buffer_pool.size; i++) {
		if (DEBUGGER_EN(MSG)) {
			pr_info("import buffer info:\n");
			rga_dump_external_buffer(&external_buffer[i]);
		}

		ret = rga_mm_import_buffer(&external_buffer[i], session);
		if (ret == 0) {
			pr_err("buffer[%d] mm import buffer failed! memory = 0x%lx, type = %s(0x%x)\n",
			       i, (unsigned long)external_buffer[i].memory,
			       rga_get_memory_type_str(external_buffer[i].type),
			       external_buffer[i].type);

			goto err_free_external_buffer;
		}

		external_buffer[i].handle = ret;
	}

	if (unlikely(copy_to_user(u64_to_user_ptr(buffer_pool.buffers_ptr),
				  external_buffer,
				  sizeof(struct rga_external_buffer) * buffer_pool.size))) {
		pr_err("rga_buffer_pool external_buffer list copy_to_user failed\n");
		ret = -EFAULT;

		goto err_free_external_buffer;
	}

err_free_external_buffer:
	kfree(external_buffer);
	return ret;
}

static long rga_ioctl_release_buffer(unsigned long arg)
{
	int i;
	int ret = 0;
	struct rga_buffer_pool buffer_pool;
	struct rga_external_buffer *external_buffer = NULL;

	if (unlikely(copy_from_user(&buffer_pool,
				    (struct rga_buffer_pool *)arg,
				    sizeof(buffer_pool)))) {
		pr_err("rga_buffer_pool  copy_from_user failed!\n");
		return -EFAULT;
	}

	if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
		pr_err("Cannot release more than %d buffers at a time!\n",
		       RGA_BUFFER_POOL_SIZE_MAX);
		return -EFBIG;
	}

	if (buffer_pool.buffers_ptr == 0) {
		pr_err("Release buffers is NULL!\n");
		return -EFAULT;
	}

	external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
				  GFP_KERNEL);
	if (external_buffer == NULL) {
		pr_err("external buffer list alloc error!\n");
		return -ENOMEM;
	}

	if (unlikely(copy_from_user(external_buffer,
				    u64_to_user_ptr(buffer_pool.buffers_ptr),
				    sizeof(struct rga_external_buffer) * buffer_pool.size))) {
		pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
		ret = -EFAULT;

		goto err_free_external_buffer;
	}

	for (i = 0; i < buffer_pool.size; i++) {
		if (DEBUGGER_EN(MSG))
			pr_info("release buffer handle[%d]\n", external_buffer[i].handle);

		ret = rga_mm_release_buffer(external_buffer[i].handle);
		if (ret < 0) {
			pr_err("buffer[%d] mm release buffer failed! handle = %d\n",
			       i, external_buffer[i].handle);

			goto err_free_external_buffer;
		}
	}

err_free_external_buffer:
	kfree(external_buffer);
	return ret;
}

static long rga_ioctl_request_create(unsigned long arg, struct rga_session *session)
{
	uint32_t id;
	uint32_t flags;

	if (copy_from_user(&flags, (void *)arg, sizeof(uint32_t))) {
		pr_err("%s failed to copy from usrer!\n", __func__);
		return -EFAULT;
	}

	id = rga_request_alloc(flags, session);

	if (copy_to_user((void *)arg, &id, sizeof(uint32_t))) {
		pr_err("%s failed to copy to usrer!\n", __func__);
		return -EFAULT;
	}

	return 0;
}

static long rga_ioctl_request_submit(unsigned long arg, bool run_enbale)
{
	int ret = 0;
	struct rga_pending_request_manager *request_manager = NULL;
	struct rga_user_request user_request;
	struct rga_request *request = NULL;

	request_manager = rga_drvdata->pend_request_manager;

	if (unlikely(copy_from_user(&user_request,
				    (struct rga_user_request *)arg,
				    sizeof(user_request)))) {
		pr_err("%s copy_from_user failed!\n", __func__);
		return -EFAULT;
	}

	ret = rga_request_check(&user_request);
	if (ret < 0) {
		pr_err("user request check error!\n");
		return ret;
	}

	if (DEBUGGER_EN(MSG))
		pr_info("config request id = %d", user_request.id);

	request = rga_request_config(&user_request);
	if (IS_ERR_OR_NULL(request)) {
		pr_err("request[%d] config failed!\n", user_request.id);
		return -EFAULT;
	}

	if (run_enbale) {
		ret = rga_request_submit(request);
		if (ret < 0) {
			pr_err("request[%d] submit failed!\n", user_request.id);
			return -EFAULT;
		}

		if (request->sync_mode == RGA_BLIT_ASYNC) {
			user_request.release_fence_fd = request->release_fence_fd;
			if (copy_to_user((struct rga_req *)arg,
					 &user_request, sizeof(user_request))) {
				pr_err("copy_to_user failed\n");
				return -EFAULT;
			}
		}
	}

	mutex_lock(&request_manager->lock);
	rga_request_put(request);
	mutex_unlock(&request_manager->lock);

	return 0;
}

static long rga_ioctl_request_cancel(unsigned long arg)
{
	uint32_t id;
	struct rga_pending_request_manager *request_manager;
	struct rga_request *request;

	request_manager = rga_drvdata->pend_request_manager;
	if (request_manager == NULL) {
		pr_err("rga_pending_request_manager is null!\n");
		return -EFAULT;
	}

	if (unlikely(copy_from_user(&id, (uint32_t *)arg, sizeof(uint32_t)))) {
		pr_err("request id copy_from_user failed!\n");
		return -EFAULT;
	}

	if (DEBUGGER_EN(MSG))
		pr_info("config cancel request id = %d", id);

	mutex_lock(&request_manager->lock);

	request = rga_request_lookup(request_manager, id);
	if (IS_ERR_OR_NULL(request)) {
		pr_err("can not find request from id[%d]", id);
		mutex_unlock(&request_manager->lock);
		return -EINVAL;
	}

	rga_request_put(request);

	mutex_unlock(&request_manager->lock);

	return 0;
}

static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *session)
{
	int ret = 0;
	int request_id;
	struct rga_user_request user_request;
	struct rga_req *rga_req;
	struct rga_request *request = NULL;
	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;

	request_id = rga_request_alloc(0, session);
	if (request_id < 0) {
		pr_err("request alloc error!\n");
		ret = request_id;
		return ret;
	}

	memset(&user_request, 0, sizeof(user_request));
	user_request.id = request_id;
	user_request.task_ptr = arg;
	user_request.task_num = 1;
	user_request.sync_mode = cmd;

	ret = rga_request_check(&user_request);
	if (ret < 0) {
		pr_err("user request check error!\n");
		goto err_free_request_by_id;
	}

	request = rga_request_config(&user_request);
	if (IS_ERR(request)) {
		pr_err("request[%d] config failed!\n", user_request.id);
		ret = -EFAULT;
		goto err_free_request_by_id;
	}

	rga_req = request->task_list;
	/* In the BLIT_SYNC/BLIT_ASYNC command, in_fence_fd needs to be set. */
	request->acquire_fence_fd = rga_req->in_fence_fd;

	if (DEBUGGER_EN(MSG)) {
		pr_info("Blit mode: request id = %d", user_request.id);
		rga_cmd_print_debug_info(rga_req);
	}

	ret = rga_request_submit(request);
	if (ret < 0) {
		pr_err("request[%d] submit failed!\n", user_request.id);
		goto err_put_request;
	}

	if (request->sync_mode == RGA_BLIT_ASYNC) {
		rga_req->out_fence_fd = request->release_fence_fd;
		if (copy_to_user((struct rga_req *)arg, rga_req, sizeof(struct rga_req))) {
			pr_err("copy_to_user failed\n");
			ret = -EFAULT;
			goto err_put_request;
		}
	}

err_put_request:
	mutex_lock(&request_manager->lock);
	rga_request_put(request);
	mutex_unlock(&request_manager->lock);

	return ret;

err_free_request_by_id:
	mutex_lock(&request_manager->lock);

	request = rga_request_lookup(request_manager, request_id);
	if (IS_ERR_OR_NULL(request)) {
		pr_err("can not find request from id[%d]", request_id);
		mutex_unlock(&request_manager->lock);
		return -EINVAL;
	}

	rga_request_free(request);

	mutex_unlock(&request_manager->lock);

	return ret;
}

static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
{
	int ret = 0;
	int i = 0;
	int major_version = 0, minor_version = 0;
	char version[16] = { 0 };
	struct rga_version_t driver_version;
	struct rga_hw_versions_t hw_versions;
	struct rga_drvdata_t *rga = rga_drvdata;
	struct rga_session *session = file->private_data;

	if (!rga) {
		pr_err("rga_drvdata is null, rga is not init\n");
		return -ENODEV;
	}

	if (DEBUGGER_EN(NONUSE))
		return 0;

	switch (cmd) {
	case RGA_BLIT_SYNC:
	case RGA_BLIT_ASYNC:
		ret = rga_ioctl_blit(arg, cmd, session);

		break;
	case RGA_CACHE_FLUSH:
	case RGA_FLUSH:
	case RGA_GET_RESULT:
		break;
	case RGA_GET_VERSION:
		sscanf(rga->scheduler[i]->version.str, "%x.%x.%*x",
			 &major_version, &minor_version);
		snprintf(version, 5, "%x.%02x", major_version, minor_version);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
		/* TODO: userspcae to get version */
		if (copy_to_user((void *)arg, version, sizeof(version)))
			ret = -EFAULT;
#else
		if (copy_to_user((void *)arg, RGA3_VERSION,
				 sizeof(RGA3_VERSION)))
			ret = -EFAULT;
#endif
		break;
	case RGA2_GET_VERSION:
		for (i = 0; i < rga->num_of_scheduler; i++) {
			if (rga->scheduler[i]->ops == &rga2_ops) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
				if (copy_to_user((void *)arg, rga->scheduler[i]->version.str,
					sizeof(rga->scheduler[i]->version.str)))
					ret = -EFAULT;
#else
				if (copy_to_user((void *)arg, RGA3_VERSION,
						sizeof(RGA3_VERSION)))
					ret = -EFAULT;
#endif
				else
					ret = true;

				break;
			}
		}

		/* This will indicate that the RGA2 version number cannot be obtained. */
		if (ret != true)
			ret = -EFAULT;

		break;

	case RGA_IOC_GET_HW_VERSION:
		/* RGA hardware version */
		hw_versions.size = rga->num_of_scheduler > RGA_HW_SIZE ?
			RGA_HW_SIZE : rga->num_of_scheduler;

		for (i = 0; i < hw_versions.size; i++) {
			memcpy(&hw_versions.version[i], &rga->scheduler[i]->version,
				sizeof(rga->scheduler[i]->version));
		}

		if (copy_to_user((void *)arg, &hw_versions, sizeof(hw_versions)))
			ret = -EFAULT;
		else
			ret = true;

		break;

	case RGA_IOC_GET_DRVIER_VERSION:
		/* Driver version */
		driver_version.major = DRIVER_MAJOR_VERISON;
		driver_version.minor = DRIVER_MINOR_VERSION;
		driver_version.revision = DRIVER_REVISION_VERSION;
		strncpy((char *)driver_version.str, DRIVER_VERSION, sizeof(driver_version.str));

		if (copy_to_user((void *)arg, &driver_version, sizeof(driver_version)))
			ret = -EFAULT;
		else
			ret = true;

		break;

	case RGA_IOC_IMPORT_BUFFER:
		rga_power_enable_all();

		ret = rga_ioctl_import_buffer(arg, session);

		rga_power_disable_all();

		break;

	case RGA_IOC_RELEASE_BUFFER:
		rga_power_enable_all();

		ret = rga_ioctl_release_buffer(arg);

		rga_power_disable_all();

		break;

	case RGA_IOC_REQUEST_CREATE:
		ret = rga_ioctl_request_create(arg, session);

		break;

	case RGA_IOC_REQUEST_SUBMIT:
		ret = rga_ioctl_request_submit(arg, true);

		break;

	case RGA_IOC_REQUEST_CONFIG:
		ret = rga_ioctl_request_submit(arg, false);

		break;

	case RGA_IOC_REQUEST_CANCEL:
		ret = rga_ioctl_request_cancel(arg);

		break;

	case RGA_IMPORT_DMA:
	case RGA_RELEASE_DMA:
	default:
		pr_err("unknown ioctl cmd!\n");
		ret = -EINVAL;
		break;
	}

	return ret;
}

#ifdef CONFIG_ROCKCHIP_RGA_DEBUGGER
static int rga_debugger_init(struct rga_debugger **debugger_p)
{
	struct rga_debugger *debugger;

	*debugger_p = kzalloc(sizeof(struct rga_debugger), GFP_KERNEL);
	if (*debugger_p == NULL) {
		pr_err("can not alloc for rga debugger\n");
		return -ENOMEM;
	}

	debugger = *debugger_p;

#ifdef CONFIG_ROCKCHIP_RGA_DEBUG_FS
	mutex_init(&debugger->debugfs_lock);
	INIT_LIST_HEAD(&debugger->debugfs_entry_list);
#endif

#ifdef CONFIG_ROCKCHIP_RGA_PROC_FS
	mutex_init(&debugger->procfs_lock);
	INIT_LIST_HEAD(&debugger->procfs_entry_list);
#endif

	rga_debugfs_init();
	rga_procfs_init();

	return 0;
}

static int rga_debugger_remove(struct rga_debugger **debugger_p)
{
	rga_debugfs_remove();
	rga_procfs_remove();

	kfree(*debugger_p);
	*debugger_p = NULL;

	return 0;
}
#endif

static int rga_open(struct inode *inode, struct file *file)
{
	struct rga_session *session = NULL;

	session = rga_session_init();
	if (IS_ERR(session))
		return PTR_ERR(session);

	file->private_data = (void *)session;

	return nonseekable_open(inode, file);
}

static int rga_release(struct inode *inode, struct file *file)
{
	struct rga_session *session = file->private_data;

	rga_session_deinit(session);

	return 0;
}

static irqreturn_t rga_irq_handler(int irq, void *data)
{
	irqreturn_t irq_ret = IRQ_NONE;
	struct rga_scheduler_t *scheduler = data;

	if (scheduler->ops->irq)
		irq_ret = scheduler->ops->irq(scheduler);

	return irq_ret;
}

static irqreturn_t rga_isr_thread(int irq, void *data)
{
	irqreturn_t irq_ret = IRQ_NONE;
	struct rga_scheduler_t *scheduler = data;
	struct rga_job *job;

	job = rga_job_done(scheduler);
	if (job == NULL) {
		pr_err("isr thread invalid job!\n");
		return IRQ_HANDLED;
	}

	if (scheduler->ops->isr_thread)
		irq_ret = scheduler->ops->isr_thread(job, scheduler);

	rga_request_release_signal(scheduler, job);

	rga_job_next(scheduler);

	rga_power_disable(scheduler);

	return irq_ret;
}

const struct file_operations rga_fops = {
	.owner = THIS_MODULE,
	.open = rga_open,
	.release = rga_release,
	.unlocked_ioctl = rga_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = rga_ioctl,
#endif
};

static struct miscdevice rga_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "rga",
	.fops = &rga_fops,
};

static const char *const old_rga2_clks[] = {
	"aclk_rga",
	"hclk_rga",
	"clk_rga",
};

static const char *const rk3588_rga2_clks[] = {
	"aclk_rga2",
	"hclk_rga2",
	"clk_rga2",
};

static const char *const rga3_core_0_clks[] = {
	"aclk_rga3_0",
	"hclk_rga3_0",
	"clk_rga3_0",
};

static const char *const rga3_core_1_clks[] = {
	"aclk_rga3_1",
	"hclk_rga3_1",
	"clk_rga3_1",
};

static const struct rga_match_data_t old_rga2_match_data = {
	.clks = old_rga2_clks,
	.num_clks = ARRAY_SIZE(old_rga2_clks),
};

static const struct rga_match_data_t rk3588_rga2_match_data = {
	.clks = rk3588_rga2_clks,
	.num_clks = ARRAY_SIZE(rk3588_rga2_clks),
};

static const struct rga_match_data_t rga3_core0_match_data = {
	.clks = rga3_core_0_clks,
	.num_clks = ARRAY_SIZE(rga3_core_0_clks),
};

static const struct rga_match_data_t rga3_core1_match_data = {
	.clks = rga3_core_1_clks,
	.num_clks = ARRAY_SIZE(rga3_core_1_clks),
};

static const struct of_device_id rga3_core0_dt_ids[] = {
	{
	 .compatible = "rockchip,rga3_core0",
	 .data = &rga3_core0_match_data,
	},
	{},
};

static const struct of_device_id rga3_core1_dt_ids[] = {
	{
	 .compatible = "rockchip,rga3_core1",
	 .data = &rga3_core1_match_data,
	},
	{},
};

static const struct of_device_id rga2_dt_ids[] = {
	{
	 .compatible = "rockchip,rga2_core0",
	 .data = &rk3588_rga2_match_data,
	},
	{
	 .compatible = "rockchip,rga2",
	 .data = &old_rga2_match_data,
	},
	{},
};

static void init_scheduler(struct rga_scheduler_t *scheduler,
			 const char *name)
{
	spin_lock_init(&scheduler->irq_lock);
	INIT_LIST_HEAD(&scheduler->todo_list);
	init_waitqueue_head(&scheduler->job_done_wq);

	if (!strcmp(name, "rga3_core0")) {
		scheduler->ops = &rga3_ops;
		/* TODO: get by hw version */
		scheduler->core = RGA3_SCHEDULER_CORE0;
	} else if (!strcmp(name, "rga3_core1")) {
		scheduler->ops = &rga3_ops;
		scheduler->core = RGA3_SCHEDULER_CORE1;
	} else if (!strcmp(name, "rga2")) {
		scheduler->ops = &rga2_ops;
		scheduler->core = RGA2_SCHEDULER_CORE0;
	}
}

static int rga_drv_probe(struct platform_device *pdev)
{
#ifndef RGA_DISABLE_PM
	int i;
#endif
	int ret = 0;
	int irq;
	struct resource *res;
	const struct rga_match_data_t *match_data;
	const struct of_device_id *match;
	struct rga_scheduler_t *scheduler;
	struct device *dev = &pdev->dev;
	struct rga_drvdata_t *data = rga_drvdata;

	if (!dev->of_node)
		return -EINVAL;

	if (!strcmp(dev_driver_string(dev), "rga3_core0"))
		match = of_match_device(rga3_core0_dt_ids, dev);
	else if (!strcmp(dev_driver_string(dev), "rga3_core1"))
		match = of_match_device(rga3_core1_dt_ids, dev);
	else if (!strcmp(dev_driver_string(dev), "rga2"))
		match = of_match_device(rga2_dt_ids, dev);
	else
		match = NULL;

	if (!match) {
		dev_err(dev, "%s missing DT entry!\n", dev_driver_string(dev));
		return -EINVAL;
	}

	scheduler = devm_kzalloc(dev, sizeof(struct rga_scheduler_t), GFP_KERNEL);
	if (scheduler == NULL) {
		pr_err("failed to allocate scheduler. dev name = %s\n", dev_driver_string(dev));
		return -ENOMEM;
	}

	init_scheduler(scheduler, dev_driver_string(dev));

	scheduler->dev = dev;

	/* map the registers */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		pr_err("get memory resource failed.\n");
		return -ENXIO;
	}

	scheduler->rga_base = devm_ioremap(dev, res->start, resource_size(res));
	if (!scheduler->rga_base) {
		pr_err("ioremap failed\n");
		ret = -ENOENT;
		return ret;
	}

	/* get the IRQ */
	match_data = match->data;

	/* there are irq names in dts */
	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(dev, "no irq %s in dts\n", dev_driver_string(dev));
		return irq;
	}

	scheduler->irq = irq;

	pr_info("%s, irq = %d, match scheduler\n", dev_driver_string(dev), irq);

	ret = devm_request_threaded_irq(dev, irq,
					rga_irq_handler,
					rga_isr_thread,
					IRQF_SHARED,
					dev_driver_string(dev), scheduler);
	if (ret < 0) {
		pr_err("request irq name: %s failed: %d\n", dev_driver_string(dev), ret);
		return ret;
	}


#ifndef RGA_DISABLE_PM
	/* clk init */
	for (i = 0; i < match_data->num_clks; i++) {
		struct clk *clk = devm_clk_get(dev, match_data->clks[i]);

		if (IS_ERR(clk))
			pr_err("failed to get %s\n", match_data->clks[i]);

		scheduler->clks[i] = clk;
	}
	scheduler->num_clks = match_data->num_clks;

	/* PM init */
	device_init_wakeup(dev, true);
	pm_runtime_enable(scheduler->dev);

	ret = pm_runtime_get_sync(scheduler->dev);
	if (ret < 0) {
		pr_err("failed to get pm runtime, ret = %d\n", ret);
		goto pm_disable;
	}

	for (i = 0; i < scheduler->num_clks; i++) {
		if (!IS_ERR(scheduler->clks[i])) {
			ret = clk_prepare_enable(scheduler->clks[i]);
			if (ret < 0) {
				pr_err("failed to enable clk\n");
				goto pm_disable;
			}
		}
	}
#endif /* #ifndef RGA_DISABLE_PM */

	scheduler->ops->get_version(scheduler);
	pr_info("%s hardware loaded successfully, hw_version:%s.\n",
		dev_driver_string(dev), scheduler->version.str);

	/* TODO: get by hw version, Currently only supports judgment 1106. */
	if (scheduler->core == RGA3_SCHEDULER_CORE0 ||
	    scheduler->core == RGA3_SCHEDULER_CORE1) {
		scheduler->data = &rga3_data;
	} else if (scheduler->core == RGA2_SCHEDULER_CORE0) {
		if (!strcmp(scheduler->version.str, "3.3.87975"))
			scheduler->data = &rga2e_1106_data;
		else if (!strcmp(scheduler->version.str, "3.6.92812") ||
			 !strcmp(scheduler->version.str, "3.7.93215"))
			scheduler->data = &rga2e_iommu_data;
		else
			scheduler->data = &rga2e_data;
	}

	data->scheduler[data->num_of_scheduler] = scheduler;

	data->num_of_scheduler++;

#ifndef RGA_DISABLE_PM
	for (i = scheduler->num_clks - 1; i >= 0; i--)
		if (!IS_ERR(scheduler->clks[i]))
			clk_disable_unprepare(scheduler->clks[i]);

	pm_runtime_put_sync(dev);
#endif /* #ifndef RGA_DISABLE_PM */

	if (scheduler->data->mmu == RGA_IOMMU) {
		scheduler->iommu_info = rga_iommu_probe(dev);
		if (IS_ERR(scheduler->iommu_info)) {
			dev_err(dev, "failed to attach iommu\n");
			scheduler->iommu_info = NULL;
		}
	}

	platform_set_drvdata(pdev, scheduler);

	pr_info("%s probe successfully\n", dev_driver_string(dev));

	return 0;

#ifndef RGA_DISABLE_PM
pm_disable:
	device_init_wakeup(dev, false);
	pm_runtime_disable(dev);
#endif /* #ifndef RGA_DISABLE_PM */

	return ret;
}

static int rga_drv_remove(struct platform_device *pdev)
{
#ifndef RGA_DISABLE_PM
	device_init_wakeup(&pdev->dev, false);
	pm_runtime_disable(&pdev->dev);
#endif /* #ifndef RGA_DISABLE_PM */

	return 0;
}

static struct platform_driver rga3_core0_driver = {
	.probe = rga_drv_probe,
	.remove = rga_drv_remove,
	.driver = {
		 .name = "rga3_core0",
		 .of_match_table = of_match_ptr(rga3_core0_dt_ids),
		 },
};

static struct platform_driver rga3_core1_driver = {
	.probe = rga_drv_probe,
	.remove = rga_drv_remove,
	.driver = {
		 .name = "rga3_core1",
		 .of_match_table = of_match_ptr(rga3_core1_dt_ids),
		 },
};

static struct platform_driver rga2_driver = {
	.probe = rga_drv_probe,
	.remove = rga_drv_remove,
	.driver = {
		 .name = "rga2",
		 .of_match_table = of_match_ptr(rga2_dt_ids),
		 },
};

static int __init rga_init(void)
{
	int ret;

	rga_drvdata = kzalloc(sizeof(struct rga_drvdata_t), GFP_KERNEL);
	if (rga_drvdata == NULL) {
		pr_err("failed to allocate driver data.\n");
		return -ENOMEM;
	}

	mutex_init(&rga_drvdata->lock);

	ret = platform_driver_register(&rga3_core0_driver);
	if (ret != 0) {
		pr_err("Platform device rga3_core0_driver register failed (%d).\n", ret);
		goto err_free_drvdata;
	}

	ret = platform_driver_register(&rga3_core1_driver);
	if (ret != 0) {
		pr_err("Platform device rga3_core1_driver register failed (%d).\n", ret);
		goto err_unregister_rga3_core0;
	}

	ret = platform_driver_register(&rga2_driver);
	if (ret != 0) {
		pr_err("Platform device rga2_driver register failed (%d).\n", ret);
		goto err_unregister_rga3_core1;
	}

	ret = rga_iommu_bind();
	if (ret < 0) {
		pr_err("rga iommu bind failed!\n");
		goto err_unregister_rga2;
	}

	ret = misc_register(&rga_dev);
	if (ret) {
		pr_err("cannot register miscdev (%d)\n", ret);
		goto err_unbind_iommu;
	}

	rga_init_timer();

	rga_mm_init(&rga_drvdata->mm);

	rga_request_manager_init(&rga_drvdata->pend_request_manager);

	rga_session_manager_init(&rga_drvdata->session_manager);

#ifdef CONFIG_ROCKCHIP_RGA_ASYNC
	rga_fence_context_init(&rga_drvdata->fence_ctx);
#endif

#ifdef CONFIG_ROCKCHIP_RGA_DEBUGGER
	rga_debugger_init(&rga_drvdata->debugger);
#endif

	pr_info("Module initialized. v%s\n", DRIVER_VERSION);

	return 0;

err_unbind_iommu:
	rga_iommu_unbind();

err_unregister_rga2:
	platform_driver_unregister(&rga2_driver);

err_unregister_rga3_core1:
	platform_driver_unregister(&rga3_core1_driver);

err_unregister_rga3_core0:
	platform_driver_unregister(&rga3_core0_driver);

err_free_drvdata:
	kfree(rga_drvdata);

	return ret;
}

static void __exit rga_exit(void)
{
#ifdef CONFIG_ROCKCHIP_RGA_DEBUGGER
	rga_debugger_remove(&rga_drvdata->debugger);
#endif

#ifdef CONFIG_ROCKCHIP_RGA_ASYNC
	rga_fence_context_remove(&rga_drvdata->fence_ctx);
#endif

	rga_mm_remove(&rga_drvdata->mm);

	rga_request_manager_remove(&rga_drvdata->pend_request_manager);

	rga_session_manager_remove(&rga_drvdata->session_manager);

	rga_cancel_timer();

	rga_iommu_unbind();

	platform_driver_unregister(&rga3_core0_driver);
	platform_driver_unregister(&rga3_core1_driver);
	platform_driver_unregister(&rga2_driver);

	misc_deregister(&rga_dev);

	kfree(rga_drvdata);

	pr_info("Module exited. v%s\n", DRIVER_VERSION);
}

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
#ifdef CONFIG_ROCKCHIP_THUNDER_BOOT
module_init(rga_init);
#elif defined CONFIG_VIDEO_REVERSE_IMAGE
fs_initcall(rga_init);
#else
late_initcall(rga_init);
#endif
#else
fs_initcall(rga_init);
#endif
module_exit(rga_exit);

/* Module information */
MODULE_AUTHOR("putin.li@rock-chips.com");
MODULE_DESCRIPTION("Driver for rga device");
MODULE_LICENSE("GPL");
#ifdef MODULE_IMPORT_NS
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
#endif