/*
 * Allwinner SoCs display driver.
 *
 * Copyright (C) 2018 Allwinner.
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2.  This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/fence.h>
#include <linux/sync_file.h>
#include <linux/file.h>
#include "dev_disp.h"
#include <video/sunxi_display2.h>

enum {
	HWC_NEW_CLIENT = 1,
	HWC_DESTROY_CLIENT,
	HWC_ACQUIRE_FENCE,
	HWC_SUBMIT_FENCE,
};

struct sync_info {
	int fd;
	unsigned int count;
};

struct hwc_fence {
	struct list_head node;
	struct fence base;
};

struct display_sync {
	unsigned timeline_count;
	unsigned submmit_count;
	unsigned current_count;
	unsigned skip_count;
	unsigned free_count;
	u64 context;
	spinlock_t fence_lock;
	struct list_head fence_list;
	char name[7];
	bool active_disp;
};

struct composer_private_data {
	struct disp_drv_info *dispopt;
	bool b_no_output;
	struct display_sync display_sync[DISP_SCREEN_NUM];
};

static struct composer_private_data composer_priv;

static inline struct display_sync *get_display_sync(struct fence *fence)
{
	return container_of(fence->lock, struct display_sync, fence_lock);
}

static inline struct hwc_fence *get_hwc_fence(struct fence *fence)
{
	return container_of(fence, struct hwc_fence, base);
}

static const char *hwc_timeline_get_driver_name (struct fence *fence)
{
	return "sunxi_hwc";
}

static const char *hwc_timeline_get_timeline_name(struct fence *fence)
{
	struct display_sync *parent;
	parent = get_display_sync(fence);
	return parent->name;
}

static bool hwc_timeline_enable_signaling(struct fence *fence)
{
	return true;
}

static bool hwc_timeline_fence_signaled(struct fence *fence)
{
	struct hwc_fence *hwc_fence;
	struct display_sync *display_sync;

	hwc_fence = get_hwc_fence(fence);
	display_sync = get_display_sync(fence);
	return hwc_fence->base.seqno - display_sync->current_count > INT_MAX;
}

static void hwc_timeline_fence_release(struct fence *fence)
{
	struct hwc_fence *hwc_fence;
	struct display_sync *display_sync;

	display_sync = get_display_sync(fence);
	hwc_fence = get_hwc_fence(fence);
	if (fence->seqno - display_sync->current_count < INT_MAX
		&& !list_empty(&hwc_fence->node)) {
		printk(KERN_ERR "Other user put the fence:%u,check it\n", fence->seqno);
		return;
	}
	kfree(hwc_fence);
	display_sync->free_count++;
}

static const struct fence_ops hwc_timeline_fence_ops = {
	.get_driver_name = hwc_timeline_get_driver_name,
	.get_timeline_name = hwc_timeline_get_timeline_name,
	.enable_signaling = hwc_timeline_enable_signaling,
	.signaled = hwc_timeline_fence_signaled,
	.wait = fence_default_wait,
	.release = hwc_timeline_fence_release,
};

static void disp_composer_proc(u32 sel)
{
	struct hwc_fence *fence, *next;
	unsigned long flags;
	struct display_sync *display_sync = &composer_priv.display_sync[sel];
	bool all_relaease;

	if (sel >= DISP_SCREEN_NUM)
		return;
	all_relaease = composer_priv.b_no_output || !display_sync->active_disp;
	if (display_sync->current_count + 1 < display_sync->submmit_count)
		display_sync->skip_count +=
			display_sync->submmit_count - 1 - display_sync->current_count;

	display_sync->current_count = display_sync->submmit_count;
	spin_lock_irqsave(&display_sync->fence_lock, flags);
	list_for_each_entry_safe(fence, next, &display_sync->fence_list,
				 node) {
		if (fence->base.seqno - display_sync->current_count > INT_MAX
			|| all_relaease) {
			list_del_init(&fence->node);
			fence_signal_locked(&fence->base);
			fence_put(&fence->base);
		} else {
			break;
		}
	}
	spin_unlock_irqrestore(&display_sync->fence_lock, flags);
}

static int hwc_aquire_fence(int disp, void *user_fence)
{
	struct display_sync *dispsync = NULL;
	struct hwc_fence *fence;
	struct sync_file *sync_file;
	unsigned long flags;
	struct sync_info sync;

	dispsync = &composer_priv.display_sync[disp];

	if (!dispsync->active_disp)
		return -ENODEV;

	fence = kzalloc(sizeof(struct hwc_fence), GFP_KERNEL);
	if (fence == NULL) {
		printk(KERN_ERR "kzlloc display pt fail\n");
		goto err_quire;
	}

	fence_init(&fence->base, &hwc_timeline_fence_ops, &dispsync->fence_lock,
		   dispsync->context, ++dispsync->timeline_count);
	sync_file = sync_file_create(&fence->base);
	if (!sync_file) {
		kfree(fence);
		goto err_quire;
	}

	sync.fd = get_unused_fd_flags(O_CLOEXEC);
	if (sync.fd < 0) {
		printk(KERN_ERR "get unused fd fail\n");
		kfree(fence);
		goto err_quire;
	}
	fd_install(sync.fd, sync_file->file);
	sync.count = fence->base.seqno;
	if (copy_to_user((void __user *)user_fence, &sync, sizeof(sync)))
		printk(KERN_ERR "copy_to_user fail.\n");

	spin_lock_irqsave(&dispsync->fence_lock, flags);
	list_add_tail(&fence->node, &dispsync->fence_list);
	spin_unlock_irqrestore(&dispsync->fence_lock, flags);

	set_bit(FENCE_FLAG_ENABLE_SIGNAL_BIT, &fence->base.flags);

	return 0;

err_quire:
	return -ENXIO;
}

static inline int hwc_submit(int disp, unsigned int sbcount)
{
	composer_priv.display_sync[disp].submmit_count = sbcount;
	if (composer_priv.b_no_output)
		disp_composer_proc(disp);
	return 0;
}

static int get_de_clk_rate(unsigned int disp, int *usr)
{
	struct disp_manager *disp_mgr;
	int rate = 254000000;

	if (DISP_SCREEN_NUM <= disp) {
		printk("%s: disp=%d\n", __func__, disp);
		return -1;
	}

	disp_mgr = composer_priv.dispopt->mgr[disp];
	if (disp_mgr && disp_mgr->get_clk_rate)
		rate = disp_mgr->get_clk_rate(disp_mgr);
	put_user(rate, usr);
	return 0;
}

static int hwc_new_client(int disp, int *user)
{
	if (composer_priv.display_sync[disp].active_disp == true) {
		get_de_clk_rate(disp, (int *)user);
		return 0;
	}
	composer_priv.display_sync[disp].timeline_count = 0;
	composer_priv.display_sync[disp].submmit_count = 0;
	composer_priv.display_sync[disp].free_count = 0;
	composer_priv.display_sync[disp].current_count = 0;
	composer_priv.display_sync[disp].skip_count = 0;
	composer_priv.display_sync[disp].active_disp = true;
	get_de_clk_rate(disp, (int *)user);
	return 0;
}

static int hwc_destroy_client(int disp)
{
	composer_priv.display_sync[disp].active_disp = false;
	disp_composer_proc(disp);
	return 0;
}

static int hwc_ioctl(unsigned int cmd, unsigned long arg)
{
	int ret = -EFAULT;

	if (cmd == DISP_HWC_COMMIT) {
		unsigned long *ubuffer;
		ubuffer = (unsigned long *)arg;
		switch (ubuffer[1]) {
		case HWC_NEW_CLIENT:
			ret = hwc_new_client((int)ubuffer[0], (int *)ubuffer[2]);
			break;
		case HWC_DESTROY_CLIENT:
			ret = hwc_destroy_client((int)ubuffer[0]);
			break;
		case HWC_ACQUIRE_FENCE:
			ret = hwc_aquire_fence(ubuffer[0], (void *)ubuffer[2]);
			break;
		case HWC_SUBMIT_FENCE:
			ret = hwc_submit(ubuffer[0], ubuffer[2]);
			break;
		default:
			pr_warn("hwc give a err iotcl.\n");
		}
	}
	return ret;
}

static int hwc_suspend(void)
{
	int i;

	composer_priv.b_no_output = 1;
	for (i = 0; i < DISP_SCREEN_NUM; i++)
		disp_composer_proc(i);
	return 0;
}

static int hwc_resume(void)
{
	composer_priv.b_no_output = 0;
	return 0;
}

int hwc_dump(char *buf)
{
	int i = 0, count = 0;

	for (i = 0; i < DISP_SCREEN_NUM; i++) {
		if (composer_priv.display_sync[i].active_disp) {
			count += sprintf(buf + count,
				"disp[%1d]all:%u, sub:%u, cur:%u, free:%u, skip:%u\n",
				i,
				composer_priv.display_sync[i].timeline_count,
				composer_priv.display_sync[i].submmit_count,
				composer_priv.display_sync[i].current_count,
				composer_priv.display_sync[i].free_count,
				composer_priv.display_sync[i].skip_count);
		}
	}
	return count;
}

s32 composer_init(struct disp_drv_info *psg_disp_drv)
{
	int i;

	disp_register_ioctl_func(DISP_HWC_COMMIT, hwc_ioctl);
#if defined(CONFIG_COMPAT)
	disp_register_compat_ioctl_func(DISP_HWC_COMMIT, hwc_ioctl);
#endif
	disp_register_sync_finish_proc(disp_composer_proc);
	disp_register_standby_func(hwc_suspend, hwc_resume);
	composer_priv.dispopt = psg_disp_drv;
	for (i = 0; i < DISP_SCREEN_NUM; i++) {
		INIT_LIST_HEAD(&composer_priv.display_sync[i].fence_list);
		spin_lock_init(&composer_priv.display_sync[i].fence_lock);
		composer_priv.display_sync[i].context = fence_context_alloc(1);
		sprintf(composer_priv.display_sync[i].name, "disp_%d", i);
		composer_priv.display_sync[i].name[6] = 0;
	}
	return 0;
}