Orange Pi5 kernel

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

#define pr_fmt(fmt) "rve: " fmt

#include "rve_job.h"
#include "rve_fence.h"
#include "rve_debugger.h"
#include "rve_reg.h"

struct rve_drvdata_t *rve_drvdata;

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

static const struct rve_backend_ops rve_ops = {
	.get_version = rve_get_version,
	.set_reg = rve_set_reg,
	.init_reg = rve_init_reg,
	.soft_reset = rve_soft_reset
};

static int rve_ctx_set_debuf_info_cb(int id, void *ptr, void *data)
{
	struct rve_internal_ctx_t *ctx = ptr;
	unsigned long flags;

	spin_lock_irqsave(&ctx->lock, flags);

	ctx->debug_info.max_cost_time_per_sec = 0;
	ctx->debug_info.hw_time_total = 0;

	spin_unlock_irqrestore(&ctx->lock, flags);

	return 0;
}

static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
{
	struct rve_drvdata_t *rve = rve_drvdata;
	struct rve_scheduler_t *scheduler = NULL;
	struct rve_pending_ctx_manager *ctx_manager;
	struct rve_job *job = NULL;
	unsigned long flags;
	int i;

	ktime_t now = ktime_get();

	for (i = 0; i < rve->num_of_scheduler; i++) {
		scheduler = rve->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;

		/* monitor */
		scheduler->session.rd_bandwidth = 0;
		scheduler->session.wr_bandwidth = 0;
		scheduler->session.cycle_cnt = 0;

		for (i = 0; i < RVE_MAX_PID_INFO; i++) {
			if (scheduler->session.pid_info[i].pid > 0)
				scheduler->session.pid_info[i].hw_time_total = 0;
		}

		spin_unlock_irqrestore(&scheduler->irq_lock, flags);

		ctx_manager = rve_drvdata->pend_ctx_manager;

		spin_lock_irqsave(&ctx_manager->lock, flags);

		idr_for_each(&ctx_manager->ctx_id_idr, &rve_ctx_set_debuf_info_cb, ctx_manager);

		spin_unlock_irqrestore(&ctx_manager->lock, flags);
	}

	hrtimer_forward_now(timer, kt);
	return HRTIMER_RESTART;
}

static void rve_init_timer(void)
{
	kt = ktime_set(0, RVE_LOAD_INTERVAL);

	hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

	timer.function = hrtimer_handler;

	hrtimer_start(&timer, kt, HRTIMER_MODE_REL);
}

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

#ifndef RVE_PD_AWAYS_ON
int rve_power_enable(struct rve_scheduler_t *scheduler)
{
	int ret = -EINVAL;
	int i;

	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;
		}
	}

	scheduler->session.pd_refcount++;

	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 rve_power_disable(struct rve_scheduler_t *scheduler)
{
	int i;

	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);

	scheduler->session.pd_refcount--;

	return 0;
}

#endif //RVE_PD_AWAYS_ON

static int rve_session_manager_init(struct rve_session_manager **session_manager_ptr)
{
	struct rve_session_manager *session_manager = NULL;

	*session_manager_ptr = kzalloc(sizeof(struct rve_session_manager), GFP_KERNEL);
	if (*session_manager_ptr == NULL) {
		pr_err("can not kzalloc for rve_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 rve session's id references.
 */
static int rve_session_free_remove_idr_cb(int id, void *ptr, void *data)
{
	struct rve_session *session = ptr;

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

	return 0;
}

static int rve_session_free_remove_idr(struct rve_session *session)
{
	struct rve_session_manager *session_manager;

	session_manager = rve_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 rve_session_manager_remove(struct rve_session_manager **session_manager_ptr)
{
	struct rve_session_manager *session_manager = *session_manager_ptr;

	mutex_lock(&session_manager->lock);

	idr_for_each(&session_manager->ctx_id_idr, &rve_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 rve_session *rve_session_init(void)
{
	struct rve_session_manager *session_manager = NULL;
	struct rve_session *session = kzalloc(sizeof(*session), GFP_KERNEL);

	session_manager = rve_drvdata->session_manager;
	if (session_manager == NULL) {
		pr_err("rve_session_manager is null!\n");
		kfree(session);
		return NULL;
	}

	mutex_lock(&session_manager->lock);

	idr_preload(GFP_KERNEL);
	session->id = idr_alloc(&session_manager->ctx_id_idr, session, 1, 0, GFP_ATOMIC);
	session_manager->session_cnt++;
	idr_preload_end();

	mutex_unlock(&session_manager->lock);

	session->tgid = current->tgid;

	return session;
}

static int rve_session_deinit(struct rve_session *session)
{
	int ctx_id;
	struct rve_pending_ctx_manager *ctx_manager;
	struct rve_internal_ctx_t *ctx;
	unsigned long flags;

	ctx_manager = rve_drvdata->pend_ctx_manager;

	spin_lock_irqsave(&ctx_manager->lock, flags);

	idr_for_each_entry(&ctx_manager->ctx_id_idr, ctx, ctx_id) {

		spin_unlock_irqrestore(&ctx_manager->lock, flags);

		if (session == ctx->session)
			kref_put(&ctx->refcount, rve_internal_ctx_kref_release);

		spin_lock_irqsave(&ctx_manager->lock, flags);
	}

	spin_unlock_irqrestore(&ctx_manager->lock, flags);

	rve_job_session_destroy(session);

	rve_session_free_remove_idr(session);
	kfree(session);

	return 0;
}

static long rve_ioctl_cmd_start(unsigned long arg, struct rve_session *session)
{
	int rve_user_ctx_id;
	int ret = 0;

	rve_user_ctx_id = rve_internal_ctx_alloc_to_get_idr_id(session);

	if (copy_to_user((void *)arg, &rve_user_ctx_id, sizeof(int)))
		ret = -EFAULT;

	return ret;
}

static long rve_ioctl_cmd_config(unsigned long arg)
{
	struct rve_user_ctx_t user_ctx;
	int ret = 0;

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

/* TODO:
 *	if (rve_user_ctx.cmd_num > RVE_CMD_NUM_MAX) {
 *		pr_err("Cannot import more than %d buffers at a time!\n",
 *			RVE_CMD_NUM_MAX);
 *		return -EFBIG;
 *	}
 */

	if (user_ctx.id <= 0) {
		pr_err("ctx id[%d] is invalid", user_ctx.id);
		return -EINVAL;
	}

	if (DEBUGGER_EN(MSG))
		pr_info("config cmd id = %d", user_ctx.id);

	/* find internal_ctx to set cmd by user ctx (internal ctx id) */
	ret = rve_job_config_by_user_ctx(&user_ctx);
	if (ret < 0) {
		pr_err("config ctx id[%d] failed!\n", user_ctx.id);
		return -EFAULT;
	}

	return ret;
}

static long rve_ioctl_cmd_end(unsigned long arg)
{
	struct rve_user_ctx_t rve_user_ctx;
	int ret = 0;

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

	if (DEBUGGER_EN(MSG))
		pr_info("config end id = %d", rve_user_ctx.id);

	/* find internal_ctx to set cmd by user ctx (internal ctx id) */
	ret = rve_job_commit_by_user_ctx(&rve_user_ctx);
	if (ret < 0) {
		pr_err("commit ctx id[%d] failed!\n", rve_user_ctx.id);
		return -EFAULT;
	}

	if (copy_to_user((struct rve_user_ctx_t *)arg,
			&rve_user_ctx, sizeof(struct rve_user_ctx_t))) {
		pr_err("rve_user_ctx copy_to_user failed\n");
		return -EFAULT;
	}

	return ret;
}

static long rve_ioctl_cmd_cancel(unsigned long arg)
{
	uint32_t rve_user_ctx_id;
	int ret = 0;

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

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

	/* find internal_ctx to set cmd by user ctx (internal ctx id) */
	ret = rve_job_cancel_by_user_ctx(rve_user_ctx_id);
	if (ret < 0) {
		pr_err("cancel ctx id[%d] failed!\n", rve_user_ctx_id);
		return -EFAULT;
	}

	return ret;
}

static long rve_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
{
	struct rve_drvdata_t *rve = rve_drvdata;

	int ret = 0;
	int i = 0;
	struct rve_version_t driver_version;
	struct rve_hw_versions_t hw_versions;
	struct rve_session *session = file->private_data;

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

	//if (DEBUGGER_EN(NONUSE))
	//	return 0;

	switch (cmd) {
	case RVE_IOC_GET_HW_VER:
		/* RVE hardware version */
		hw_versions.size = rve->num_of_scheduler > RVE_HW_SIZE ?
			RVE_HW_SIZE : rve->num_of_scheduler;

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

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

		break;

	case RVE_IOC_GET_VER:
		/* Driver version */
		driver_version.major = DRIVER_MAJOR_VERSION;
		driver_version.minor = DRIVER_MINOR_VERSION;
		driver_version.revision = DRIVER_REVISION_VERSION;
		driver_version.prod_num = 0;
		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 RVE_IOC_START_CONFIG:
		ret = rve_ioctl_cmd_start(arg, session);

		break;

	case RVE_IOC_END_CONFIG:
		ret = rve_ioctl_cmd_end(arg);

		break;

	case RVE_IOC_CMD_CONFIG:
		ret = rve_ioctl_cmd_config(arg);

		break;

	case RVE_IOC_CANCEL_CONFIG:
		ret = rve_ioctl_cmd_cancel(arg);

		break;

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

	return ret;
}

#ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
static int rve_debugger_init(struct rve_debugger **debugger_p)
{
	struct rve_debugger *debugger;

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

	debugger = *debugger_p;

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

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

	rve_debugfs_init();
	rve_procfs_init();

	return 0;
}

static int rve_debugger_remove(struct rve_debugger **debugger_p)
{
	rve_debugfs_remove();
	rve_procfs_remove();

	kfree(*debugger_p);
	*debugger_p = NULL;

	return 0;
}
#endif

static int rve_open(struct inode *inode, struct file *file)
{
	struct rve_session *session = NULL;

	session = rve_session_init();
	if (!session)
		return -ENOMEM;

	file->private_data = (void *)session;

	return nonseekable_open(inode, file);
}

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

	rve_session_deinit(session);

	return 0;
}

static irqreturn_t rve_irq_handler(int irq, void *data)
{
	struct rve_scheduler_t *scheduler = data;
	u32 error_flag;

	error_flag = rve_read(RVE_SWREG6_IVE_WORK_STA, scheduler);

	if (error_flag & 0x6) {
		pr_err("irq thread work_status[%x]\n", error_flag);

		if (error_flag & 0x2)
			pr_err("irq: bus error");
		else if (error_flag & 0x4)
			pr_err("irq: timeout error");

		scheduler->ops->soft_reset(scheduler);
	}

	/* clear INT */
	rve_write(0x30000, RVE_SWREG1_IVE_IRQ, scheduler);

	return IRQ_WAKE_THREAD;
}

static irqreturn_t rve_irq_thread(int irq, void *data)
{
	struct rve_scheduler_t *scheduler = data;
	struct rve_job *job;
	u32 error_flag;

	job = scheduler->running_job;
	scheduler->session.total_int_cnt++;

	if (!job) {
		pr_err("running job is invalid on irq thread\n");
		return IRQ_HANDLED;
	}

	error_flag = rve_read(RVE_SWREG6_IVE_WORK_STA, scheduler);

	if (DEBUGGER_EN(INT_FLAG)) {
		pr_err("irq thread work_status[%x]\n", error_flag);
		if (error_flag & 0x6) {
			if (error_flag & 0x2)
				pr_err("irq: bus error");
			else if (error_flag & 0x4)
				pr_err("irq: timeout error");
		}
	}

	/* if llp mode*/
	if ((error_flag & RVE_LLP_MODE) &&
		(!(error_flag & RVE_LLP_DONE))) {
		if (DEBUGGER_EN(INT_FLAG))
			pr_err("irq: llp mode need to skip rve_job_done");
			goto skip_job_done;
	}

	rve_job_done(scheduler, 0);

skip_job_done:
	return IRQ_HANDLED;
}

const struct file_operations rve_fops = {
	.owner = THIS_MODULE,
	.open = rve_open,
	.release = rve_release,
	.unlocked_ioctl = rve_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = rve_ioctl,
#endif
};

static struct miscdevice rve_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "rve",
	.fops = &rve_fops,
};

static const char *const rve_clks[] = {
	"aclk_rve",
	"hclk_rve",
};

static const struct rve_irqs_data_t rve_irqs[] = {
	{"rve_irq", rve_irq_handler, rve_irq_thread}
};

static const struct rve_match_data_t rve_match_data = {
	.clks = rve_clks,
	.num_clks = ARRAY_SIZE(rve_clks),
	.irqs = rve_irqs,
	.num_irqs = ARRAY_SIZE(rve_irqs)
};

static const struct of_device_id rve_dt_ids[] = {
	{
	 .compatible = "rockchip,rve",
	 .data = &rve_match_data,
	},
	{},
};

static void init_scheduler(struct rve_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, "rve")) {
		scheduler->ops = &rve_ops;
		scheduler->core = RVE_SCHEDULER_CORE0;
	}
}

static int rve_drv_probe(struct platform_device *pdev)
{
	struct rve_drvdata_t *data = rve_drvdata;
	struct resource *res;
	int ret = 0;
	const struct of_device_id *match = NULL;
	struct device *dev = &pdev->dev;
	const struct rve_match_data_t *match_data;
	int i = 0, irq;
	struct rve_scheduler_t *scheduler = NULL;

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

	if (!strcmp(dev_driver_string(dev), "rve"))
		match = of_match_device(rve_dt_ids, dev);

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

	scheduler =
		devm_kzalloc(&pdev->dev, sizeof(struct rve_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 = &pdev->dev;

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

	scheduler->rve_base =
		devm_ioremap(&pdev->dev, res->start, resource_size(res));
	if (!scheduler->rve_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", match_data->irqs[0].name);
		return irq;
	}

	scheduler->irq = irq;

	pr_info("%s, irq = %d, match scheduler\n",
			match_data->irqs[0].name, irq);

	ret = devm_request_threaded_irq(dev, irq,
			match_data->irqs[0].irq_hdl,
			match_data->irqs[0].irq_thread, IRQF_SHARED,
			dev_driver_string(dev), scheduler);
	if (ret < 0) {
		pr_err("request irq name: %s failed: %d\n",
				match_data->irqs[0].name, ret);
		return ret;
	}

#ifndef RVE_PD_AWAYS_ON
	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;
#endif

	platform_set_drvdata(pdev, scheduler);

	device_init_wakeup(dev, true);

	/* PM init */
#ifndef RVE_PD_AWAYS_ON
	pm_runtime_enable(&pdev->dev);

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

	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 failed;
			}
		}
	}
#endif //RVE_PD_AWAYS_ON

	scheduler->ops->get_version(scheduler);
	pr_info("Driver loaded successfully rve[%d] ver:%s\n", i,
		scheduler->version.str);

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

	data->num_of_scheduler++;

#ifndef RVE_PD_AWAYS_ON
	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(&pdev->dev);
#endif //RVE_PD_AWAYS_ON

	pr_info("probe successfully\n");

	return 0;

#ifndef RVE_PD_AWAYS_ON
failed:
	device_init_wakeup(dev, false);
	pm_runtime_disable(dev);

	return ret;
#endif //RVE_PD_AWAYS_ON
}

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

	return 0;
}

static struct platform_driver rve_driver = {
	.probe = rve_drv_probe,
	.remove = rve_drv_remove,
	.driver = {
		 .name = "rve",
		 .of_match_table = of_match_ptr(rve_dt_ids),
		 },
};

static int __init rve_init(void)
{
	int ret;

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

	mutex_init(&rve_drvdata->lock);

	wake_lock_init(&rve_drvdata->wake_lock, WAKE_LOCK_SUSPEND, "rve");

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

#ifdef CONFIG_SYNC_FILE
	rve_drvdata->fence_ctx = rve_fence_context_alloc();
	if (IS_ERR(rve_drvdata->fence_ctx)) {
		pr_err("failed to allocate fence context for RVE\n");
		ret = PTR_ERR(rve_drvdata->fence_ctx);
		return ret;
	}
#endif

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

	rve_ctx_manager_init(&rve_drvdata->pend_ctx_manager);

	rve_session_manager_init(&rve_drvdata->session_manager);

	rve_init_timer();

#ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
	rve_debugger_init(&rve_drvdata->debugger);
#endif

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

	return 0;
}

static void __exit rve_exit(void)
{
#ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
	rve_debugger_remove(&rve_drvdata->debugger);
#endif

	rve_ctx_manager_remove(&rve_drvdata->pend_ctx_manager);

	rve_session_manager_remove(&rve_drvdata->session_manager);

	wake_lock_destroy(&rve_drvdata->wake_lock);

#ifdef CONFIG_SYNC_FILE
	rve_fence_context_free(rve_drvdata->fence_ctx);
#endif

	rve_cancel_timer();

	platform_driver_unregister(&rve_driver);

	misc_deregister(&rve_dev);

	kfree(rve_drvdata);
}

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
#ifdef CONFIG_ROCKCHIP_THUNDER_BOOT
module_init(rve_init);
#else
late_initcall(rve_init);
#endif
#else
fs_initcall(rve_init);
#endif
module_exit(rve_exit);

/* Module information */
MODULE_AUTHOR("putin.li@rock-chips.com");
MODULE_DESCRIPTION("Driver for rve device");
MODULE_LICENSE("GPL");