// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */

#include <drm/drm.h>
#include <drm/drmP.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_uapi.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_blend.h>
#include <linux/dma-buf.h>
#include <linux/fb.h>
#include <linux/amlogic/ion.h>
#if IS_ENABLED(CONFIG_AMLOGIC_DEBUG_ATRACE)
#define KERNEL_ATRACE_TAG KERNEL_ATRACE_TAG_DRM
#include <trace/events/meson_atrace.h>
#endif

#include "meson_drv.h"
#include "meson_gem.h"
#include "meson_fb.h"
#include "meson_fbdev.h"
#include "meson_plane.h"
#include "meson_vpu_pipeline.h"

#define PREFERRED_BPP		32
#define PREFERRED_DEPTH	32
#define MESON_DRM_MAX_CONNECTOR	2
#define MAX_RETRY_CNT 20

static u32 rdma_chk_addr[] = {
	VIU_OSD1_TCOLOR_AG3,
	VIU_OSD2_TCOLOR_AG3,
	VIU_OSD3_TCOLOR_AG3,
};

static size_t cal_fbdev_afbc_size(struct fb_info *info)
{
	size_t size;
	u32 aligned_width, aligned_height, pixel_size;
	u32 stride, buf_num, buf_size, block_count;

	aligned_width = ALIGN(info->var.xres, AFBC_TILED_HEADERS_WIDEBLK_WIDTH_ALIGN);
	aligned_height = ALIGN(info->var.yres, AFBC_TILED_HEADERS_WIDEBLK_HEIGHT_ALIGN);
	pixel_size = info->var.bits_per_pixel / 8;
	stride = aligned_width * pixel_size;
	stride = ALIGN(stride, 64);
	block_count = aligned_width / AFBC_PIXELS_PER_BLOCK *
		aligned_height / AFBC_PIXELS_PER_BLOCK;
	buf_size = stride * aligned_height +
		ALIGN(block_count * AFBC_HEADER_BYTES_PER_BLOCKENTRY, AFBC_BODY_BYTE_ALIGNMENT);
	buf_num = info->var.yres_virtual / info->var.yres;
	buf_size = roundup(buf_size, BIT(CONFIG_CMA_ALIGNMENT) * PAGE_SIZE);
	size = buf_size * buf_num;

	return size;
}

static int am_meson_fbdev_alloc_fb_gem(struct fb_info *info)
{
	struct am_meson_fb *meson_fb;
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct drm_framebuffer *fb = helper->fb;
	struct drm_device *dev = helper->dev;
	struct am_meson_gem_object *meson_gem;
	void *vaddr = NULL;
	struct page **pages;
	struct page **tmp;
	struct sg_page_iter piter;
	pgprot_t pgprot;
	int npages;
	struct meson_drm *priv = dev->dev_private;
	struct meson_of_conf *conf = &priv->of_conf;
	size_t size = cal_fbdev_afbc_size(info);

	if (!conf->afbc_aligned_size)
		size = info->screen_size;

	if (!fbdev->fb_gem) {
		meson_gem = am_meson_gem_object_create(dev, 0, size);
		if (IS_ERR(meson_gem)) {
			DRM_ERROR("alloc memory %d fail\n", (u32)size);
			return -ENOMEM;
		}
#ifndef CONFIG_AMLOGIC_ION_DEV
		if (!meson_gem->is_dma) {
			DRM_WARN("ion is not supported anymore!\n");
			meson_gem_object_free(&meson_gem->base);
			return -EINVAL;
		}
#endif

		fbdev->fb_gem = &meson_gem->base;
		fb = helper->fb;
		meson_fb = container_of(fb, struct am_meson_fb, base);
		if (!meson_fb) {
			DRM_INFO("meson_fb is NULL!\n");
			return -EINVAL;
		}
		meson_fb->bufp[0] = meson_gem;
		if (meson_gem->is_dma) {
			npages = PAGE_ALIGN(meson_gem->base.size) / PAGE_SIZE;
			pages = vmalloc(array_size(npages, sizeof(struct page *)));
			tmp = pages;

			if (!pages)
				return -ENOMEM;

			pgprot = pgprot_writecombine(PAGE_KERNEL);

			for_each_sgtable_page(meson_gem->sg, &piter, 0) {
				WARN_ON(tmp - pages >= npages);
				*tmp++ = sg_page_iter_page(&piter);
			}

			vaddr = vmap(pages, npages, VM_MAP, pgprot);
			vfree(pages);
		} else {
#ifdef CONFIG_AMLOGIC_ION_DEV
			vaddr = ion_heap_map_kernel(meson_gem->ionbuffer->heap,
						meson_gem->ionbuffer);
#endif
		}
		info->screen_base = (char __iomem *)vaddr;
		info->fix.smem_start = meson_gem->addr;

		MESON_DRM_FBDEV("alloc memory %d done\n", (u32)size);
	} else {
		MESON_DRM_FBDEV("no need repeate alloc memory %d\n", (u32)size);
	}
	return 0;
}

static void am_meson_fbdev_free_fb_gem(struct fb_info *info)
{
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev;
	struct drm_framebuffer *fb;
	struct am_meson_fb *meson_fb;

	if (!helper) {
		DRM_ERROR("fb helper is NULL!\n");
		return;
	}

	fbdev = container_of(helper, struct meson_drm_fbdev, base);
	if (fbdev && fbdev->fb_gem) {
#ifdef CONFIG_AMLOGIC_ION_DEV
		struct drm_gem_object *gem_obj = fbdev->fb_gem;
		struct am_meson_gem_object *meson_gem = container_of(gem_obj,
					struct am_meson_gem_object, base);

		if (!meson_gem->is_dma)
			ion_heap_unmap_kernel(meson_gem->ionbuffer->heap,
					meson_gem->ionbuffer);
#endif
		info->screen_base = NULL;

		meson_gem_object_free(fbdev->fb_gem);
		fbdev->fb_gem = NULL;

		fb = helper->fb;
		if (fb) {
			meson_fb = container_of(fb, struct am_meson_fb, base);
			if (meson_fb)
				meson_fb->bufp[0] = NULL;
			else
				DRM_ERROR("meson_fb is NULL!\n");
		} else {
			DRM_ERROR("drm framebuffer is NULL!\n");
		}

		MESON_DRM_FBDEV("free memory done\n");
	} else {
		MESON_DRM_FBDEV("memory already free before\n");
	}
}

static int am_meson_fbdev_open(struct fb_info *info, int arg)
{
	int ret = 0;
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct am_osd_plane *osdplane = container_of(fbdev->plane, struct am_osd_plane, base);

	MESON_DRM_FBDEV("IN,pid[%s %d],plane_id[%d],screen_size[%ld],res_virtual[%d %d]\n",
		current->comm, current->pid, osdplane->plane_index,
		info->screen_size, info->var.xres_virtual, info->var.yres_virtual);
	ret = am_meson_fbdev_alloc_fb_gem(info);
	MESON_DRM_FBDEV("OUT, ret=%d\n", ret);
	return ret;
}

static int am_meson_fbdev_release(struct fb_info *info, int arg)
{
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct am_osd_plane *osdplane = container_of(fbdev->plane, struct am_osd_plane, base);

	MESON_DRM_FBDEV("IN, pid[%s %d], plane_id[%d]\n",
		current->comm, current->pid, osdplane->plane_index);
	MESON_DRM_FBDEV("may no need to release memory\n");
	MESON_DRM_FBDEV("OUT\n");

	return 0;
}

static int am_meson_fbdev_mmap(struct fb_info *info,
			       struct vm_area_struct *vma)
{
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct am_meson_gem_object *meson_gem;

	meson_gem = container_of(fbdev->fb_gem,
				 struct am_meson_gem_object, base);

	return meson_gem_prime_mmap(fbdev->fb_gem, vma);
}

static int am_meson_drm_fbdev_sync(struct fb_info *info)
{
	return 0;
}

static int am_meson_drm_fbdev_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
	int count, index;
	int r = 0;
	u16 *red, *green, *blue, *transp;
	u16 trans = 0xffff;

	red     = cmap->red;
	green   = cmap->green;
	blue    = cmap->blue;
	transp  = cmap->transp;
	index   = cmap->start;
	MESON_DRM_FBDEV("visual = %d, len = %d\n", info->fix.visual, cmap->len);

	if (info->fix.visual == FB_VISUAL_PSEUDOCOLOR) {
		for (count = 0; count < cmap->len; count++) {
			if (transp)
				trans = *transp++;
			if (info->fbops->fb_setcolreg)
				r = info->fbops->fb_setcolreg(index++, *red++, *green++, *blue++,
					trans, info);
			if (r != 0)
				return r;
		}
	} else {
		r = drm_fb_helper_setcmap(cmap, info);
		return r;
	}

	return 0;
}

static int
am_meson_drm_fbdev_setcolreg(unsigned int regno, unsigned int red, unsigned int green,
			     unsigned int blue, unsigned int transp, struct fb_info *info)
{
	struct drm_fb_helper *helper = info->par;
	struct fb_var_screeninfo *var = &info->var;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct drm_device *dev = helper->dev;
	struct am_osd_plane *osd_plane = to_am_osd_plane(fbdev->plane);

	MESON_DRM_FBDEV("pixel is %d bits, palette index-%d\n",
		var->bits_per_pixel, regno);
	if (var->bits_per_pixel == 8 && regno < 256) {
		drm_modeset_lock_all(dev);
		fbdev->fbdev_rec_palette[regno] = ((red & 0xff) << 24) |
						  ((green & 0xff) << 16) |
						  ((blue  & 0xff) <<  8) |
						  (transp & 0xff);
		osd_plane->receive_palette = &fbdev->fbdev_rec_palette[0];
		MESON_DRM_FBDEV("palette index-%d value-0x%x.\n", regno,
			osd_plane->receive_palette[regno]);
		drm_modeset_unlock_all(dev);
	}

	return 0;
}

/**
 * am_meson_drm_fb_helper_check_var - implementation for ->fb_check_var
 * @var: screeninfo to check
 * @info: fbdev registered by the helper
 */
static int am_meson_drm_fb_helper_check_var(struct fb_var_screeninfo *var,
					    struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_framebuffer *fb = fb_helper->fb;
	int depth;

	if (var->pixclock != 0 || in_dbg_master()) {
		DRM_ERROR("FAILED.\n");
		return -EINVAL;
	}

	/*
	 * Changes struct fb_var_screeninfo are currently not pushed back
	 * to KMS, hence fail if different settings are requested.
	 */
	MESON_DRM_FBDEV("fb requested w/h/bpp  %dx%d-%d (virtual %dx%d)\n",
		  var->xres, var->yres, var->bits_per_pixel,
		  var->xres_virtual, var->yres_virtual);
	MESON_DRM_FBDEV("current fb w/h/bpp %dx%d-%d\n",
		  fb->width, fb->height, fb->format->depth);
	if (var->bits_per_pixel != fb->format->depth ||
	    var->xres_virtual != fb->width ||
	    var->yres_virtual != fb->height)
		MESON_DRM_FBDEV("need realloc buffer\n");

	switch (var->bits_per_pixel) {
	case 16:
		depth = (var->green.length == 6) ? 16 : 15;
		break;
	case 32:
		depth = (var->transp.length > 0) ? 32 : 24;
		break;
	default:
		depth = var->bits_per_pixel;
		break;
	}

	switch (depth) {
	case 8:
		var->red.offset = 0;
		var->green.offset = 0;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 15:
		var->red.offset = 10;
		var->green.offset = 5;
		var->blue.offset = 0;
		var->red.length = 5;
		var->green.length = 5;
		var->blue.length = 5;
		var->transp.length = 1;
		var->transp.offset = 15;
		break;
	case 16:
		var->red.offset = 11;
		var->green.offset = 5;
		var->blue.offset = 0;
		var->red.length = 5;
		var->green.length = 6;
		var->blue.length = 5;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 24:
		var->red.offset = 16;
		var->green.offset = 8;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 32:
		var->red.offset = 16;
		var->green.offset = 8;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 8;
		var->transp.offset = 24;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static void am_meson_drm_wait_one_vblank(struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(fb_helper, struct meson_drm_fbdev, base);
	int crtc_index;
	struct drm_vblank_crtc *vblank;

	if (fbdev->plane->crtc)
		crtc_index = fbdev->plane->crtc->index;
	else if (fbdev->modeset.crtc)
		crtc_index = fbdev->modeset.crtc->index;
	else
		crtc_index = 0;

	vblank = &fb_helper->dev->vblank[crtc_index];
	if (vblank->enabled)
		drm_wait_one_vblank(fb_helper->dev, crtc_index);
	else
		MESON_DRM_FBDEV("crtc-%d is disabled, can not wait vblank.\n",
			crtc_index);
}

/**
 * drm_fb_helper_set_par - implementation for ->fb_set_par
 * @info: fbdev registered by the helper
 *
 * This will let fbcon do the mode init and is called at initialization time by
 * the fbdev core when registering the driver, and later on through the hotplug
 * callback.
 */
int am_meson_drm_fb_helper_set_par(struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct fb_var_screeninfo *var = &info->var;
	struct drm_framebuffer *fb = fb_helper->fb;
	struct meson_drm_fbdev *fbdev = container_of(fb_helper, struct meson_drm_fbdev, base);
	struct drm_gem_object *fb_gem = fbdev->fb_gem;
	struct drm_plane *plane = fbdev->plane;
	struct drm_fb_helper_surface_size sizes;
	struct drm_device *dev = fb_helper->dev;
	struct drm_mode_fb_cmd2 mode_cmd = { 0 };
	unsigned int bytes_per_pixel, pitches;
	u32 xres_set = var->xres;
	u32 yres_set = var->yres;
	int depth;
	unsigned long screen_size;
	unsigned long old_screen_size = info->screen_size;

	if (oops_in_progress)
		return -EBUSY;

	if (var->pixclock != 0) {
		DRM_ERROR("PIXEL CLOCK SET\n");
		return -EINVAL;
	}

	DRM_INFO("pid[%s %d], plane_id[%d], fb_gem[%px]\n"
		"bpp[%d %d], fb[%d %d], res[%d %d], res_virtual[%d %d]\n",
		current->comm, current->pid, plane->index, fb_gem,
		var->bits_per_pixel, fb->format->depth,
		fb->width, fb->height, var->xres, var->yres,
		var->xres_virtual, var->yres_virtual);

	if (var->bits_per_pixel != fb->format->depth ||
		var->xres_virtual != fb->width ||
		var->yres_virtual != fb->height ||
		!fb_gem) {
		fbdev->vscreen_info_changed = true;
		/*realloc framebuffer, free old then alloc new gem*/
		sizes.fb_height = var->yres_virtual;
		sizes.fb_width = var->xres_virtual;
		sizes.surface_width = sizes.fb_width;
		sizes.surface_height = sizes.fb_height;
		sizes.surface_bpp = var->bits_per_pixel;
		sizes.surface_depth = PREFERRED_DEPTH;

		switch (var->bits_per_pixel) {
		case 16:
			depth = (var->green.length == 6) ? 16 : 15;
			break;
		case 32:
			depth = (var->transp.length > 0) ? 32 : 24;
			break;
		default:
			depth = var->bits_per_pixel;
			break;
		}

		bytes_per_pixel = DIV_ROUND_UP(sizes.surface_bpp, 8);
		mode_cmd.width = sizes.surface_width;
		mode_cmd.height = sizes.surface_height;
		mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes.surface_bpp, depth);
		mode_cmd.pitches[0] = ALIGN(mode_cmd.width * bytes_per_pixel, 64);
		MESON_DRM_FBDEV("length[%d %d %d %d]offset[%d %d %d %d]format:%c%c%c%c\n",
			var->red.length, var->green.length,
			var->blue.length, var->transp.length,
			var->red.offset, var->green.offset,
			var->blue.offset, var->transp.offset,
			(mode_cmd.pixel_format & 0xFF),
			((mode_cmd.pixel_format >> 8) & 0xFF),
			((mode_cmd.pixel_format >> 16) & 0xFF),
			((mode_cmd.pixel_format >> 24) & 0xFF));

		pitches = ALIGN(sizes.fb_width * bytes_per_pixel, 64);
		screen_size = pitches * sizes.fb_height;

		if (fb_gem && fb_gem->size < info->screen_size) {
			DRM_INFO("%s, GEM SIZE is not enough: %ld < %ld\n",
				__func__, (unsigned long)fb_gem->size, screen_size);
			am_meson_fbdev_free_fb_gem(info);
			fb_gem = NULL;
		}

		if (!fb_gem) {
			info->screen_size = screen_size;
			if (am_meson_fbdev_alloc_fb_gem(info)) {
				DRM_ERROR("realloc fb fail, screen_size[%ld->%ld]\n",
					screen_size, old_screen_size);
				info->screen_size = old_screen_size;
				return -ENOMEM;
			}
		}

		fb->width = sizes.fb_width;
		fb->height = sizes.fb_height;
		fb->pitches[0] =  ALIGN(fb->width * bytes_per_pixel, 64);
		fb->format = drm_get_format_info(dev, &mode_cmd);

		info->screen_size = fb->pitches[0] * fb->height;
		//info->fix.smem_len = info->screen_size;

		drm_fb_helper_fill_info(info, fb_helper, &sizes);
		/* fix some bug in drm_fb_helper_full_info */
		var->xres = xres_set;
		var->yres = yres_set;
	}

	am_meson_drm_wait_one_vblank(info);

	return 0;
}

/* sync of drm_client_modeset_commit_atomic(),
 * 1. add fbdev for non-primary plane.
 * 2. remove crtc set.
 */
static int am_meson_drm_fb_pan_display(struct fb_var_screeninfo *var,
				       struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(fb_helper, struct meson_drm_fbdev, base);
	struct drm_device *dev = fb_helper->dev;
	struct drm_atomic_state *state;
	struct drm_plane_state *plane_state;
	struct drm_plane *plane = fbdev->plane;
	struct drm_mode_set *mode_set;
	int hdisplay, vdisplay;
	ktime_t start1, end1, start2, end2;
	s64 commit_time_ms, total_time_ms;
	int ret;

	if (fbdev->blank) {
		MESON_DRM_FBDEV("skip blank.\n");
		return 0;
	}

	if (fbdev->vscreen_info_changed) {
		fbdev->vscreen_info_changed = false;
		DRM_INFO("%s, skip set_par's pan display\n", __func__);
		return 0;
	}

	MESON_DRM_FBDEV("IN, pid[%s %d], plane_id[%d], plane_type[%d], fb[%p]\n",
		current->comm, current->pid, plane->index,
		plane->type, fb_helper->fb);

#if IS_ENABLED(CONFIG_AMLOGIC_DEBUG_ATRACE)
	ATRACE_BEGIN("fbdev_pan_display");
#endif
	start1 = ktime_get();

	drm_modeset_lock_all(dev);

	state = drm_atomic_state_alloc(dev);
	if (!state) {
		ret = -ENOMEM;
		goto unlock_exit;
	}

	state->acquire_ctx = dev->mode_config.acquire_ctx;
retry:

	mode_set = &fbdev->modeset;

	/*update plane state, refer to drm_atomic_plane_set_property()*/
	plane_state = drm_atomic_get_plane_state(state, plane);
	if (IS_ERR(plane_state)) {
		ret = PTR_ERR(plane_state);
		goto fail;
	}

	ret = drm_atomic_set_crtc_for_plane(plane_state, mode_set->crtc);
	if (ret != 0) {
		DRM_ERROR("set crtc for plane failed.\n");
		goto fail;
	}

	drm_mode_get_hv_timing(&mode_set->crtc->mode, &hdisplay, &vdisplay);
	if (fbdev->dst_changed.w && fbdev->dst_changed.h) {
		plane_state->crtc_x = fbdev->dst_changed.x;
		plane_state->crtc_y = fbdev->dst_changed.y;
		plane_state->crtc_w = fbdev->dst_changed.w;
		plane_state->crtc_h = fbdev->dst_changed.h;
	} else {
		plane_state->crtc_x = 0;
		plane_state->crtc_y = 0;
		plane_state->crtc_w = hdisplay;
		plane_state->crtc_h = vdisplay;
	}

	drm_atomic_set_fb_for_plane(plane_state, fb_helper->fb);
	if (fb_helper->fb) {
		plane_state->src_x = var->xoffset << 16;
		plane_state->src_y = var->yoffset << 16;
		plane_state->src_w = var->xres << 16;
		plane_state->src_h = var->yres << 16;
		plane_state->zpos = fbdev->zorder;
	} else {
		plane_state->src_x = 0;
		plane_state->src_y = 0;
		plane_state->src_w = 0;
		plane_state->src_h = 0;
		plane_state->zpos = fbdev->zorder;
	}
	/* fix alpha */
	plane_state->pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;

	MESON_DRM_FBDEV("update fb [%x-%x, %xx%x]-%d->[%d-%d, %dx%d]\n",
		plane_state->src_x, plane_state->src_y,
		plane_state->src_w, plane_state->src_h,
		plane_state->zpos,
		plane_state->crtc_x, plane_state->crtc_y,
		plane_state->crtc_w, plane_state->crtc_h);

	state->legacy_cursor_update = true;
	start2 = ktime_get();
	ret = drm_atomic_commit(state);
	end2 = ktime_get();
	commit_time_ms = ktime_ms_delta(end2, start2);
	if (ret != 0)
		goto fail;

	info->var.xoffset = var->xoffset;
	info->var.yoffset = var->yoffset;

fail:
	if (ret == -EDEADLK)
		goto backoff;

	drm_atomic_state_put(state);

unlock_exit:
	drm_modeset_unlock_all(dev);

	if (ret)
		DRM_ERROR("failed, ret = %d\n", ret);
	else
		MESON_DRM_FBDEV("OUT\n");

	end1 = ktime_get();
	total_time_ms = ktime_ms_delta(end1, start1);
#if IS_ENABLED(CONFIG_AMLOGIC_DEBUG_ATRACE)
	ATRACE_END();
	ATRACE_COUNTER("fbdev_pan_display", total_time_ms);
#endif
	if (total_time_ms > am_drm_param.fbdev_pan_display_threshold)
		DRM_WARN("fbdev pan display cost (%lld %lld) ms, it is too long\n",
			commit_time_ms, total_time_ms);

	return ret;

backoff:
	drm_atomic_state_clear(state);
	drm_modeset_backoff(state->acquire_ctx);

	goto retry;
}

static void meson_drm_modeset_lock_crtc(struct drm_crtc *crtc,
			struct drm_plane *plane, struct drm_modeset_acquire_ctx *ctx)
{
	int ret;

	drm_modeset_acquire_init(ctx, 0);

retry:
	ret = drm_modeset_lock(&crtc->mutex, ctx);
	if (ret)
		goto fail;

	if (plane) {
		ret = drm_modeset_lock(&plane->mutex, ctx);
		if (ret)
			goto fail;

		if (plane->crtc) {
			ret = drm_modeset_lock(&plane->crtc->mutex, ctx);
			if (ret)
				goto fail;
		}
	}

	return;

fail:
	if (ret == -EDEADLK) {
		drm_modeset_backoff(ctx);
		goto retry;
	}
}

void meson_drm_modeset_unlock_crtc(struct drm_crtc *crtc, struct drm_modeset_acquire_ctx *ctx)
{
	drm_modeset_drop_locks(ctx);
	drm_modeset_acquire_fini(ctx);
}

/**
 * the implement if different from drm_fb_helper.
 * for plane based fbdev, we only disable corresponding plane
 * but not the whole crtc.
 */
int am_meson_drm_fb_blank(int blank, struct fb_info *info)
{
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct drm_device *dev = helper->dev;
	struct meson_drm *priv = dev->dev_private;
	struct drm_crtc *crtc = NULL;
	struct drm_modeset_acquire_ctx ctx;
	int ret = 0;

	if (blank == 0) {
		MESON_DRM_FBDEV("IN, pid[%s %d] meson_fbdev[%s]fb[%p] goto unblank.\n",
			current->comm, current->pid,
			fbdev->plane->name, fbdev->plane->fb);
		fbdev->blank = false;
		ret = am_meson_drm_fb_pan_display(&info->var, info);

		am_meson_drm_wait_one_vblank(info);
	} else {
		MESON_DRM_FBDEV("IN, pid[%s %d] meson_fbdev[%s]fb[%p] goto blank.\n",
			current->comm, current->pid,
			fbdev->plane->name, fbdev->plane->fb);

		if (fbdev->plane->crtc) {
			crtc = fbdev->plane->crtc;
		} else if (fbdev->modeset.crtc) {
			crtc = fbdev->modeset.crtc;
		}
		if (!crtc) {
			DRM_ERROR("crtc is null, skip %s blank\n", fbdev->plane->name);
			return 0;
		}

		meson_drm_modeset_lock_crtc(crtc, fbdev->plane, &ctx);
		if (priv->pan_async_commit_ran) {
			DRM_INFO("Force to wait one vblank!\n");
			am_meson_drm_wait_one_vblank(info);
		}
		drm_atomic_helper_disable_plane(fbdev->plane, &ctx);
		meson_drm_modeset_unlock_crtc(crtc, &ctx);

		fbdev->blank = true;
	}

	MESON_DRM_FBDEV("OUT, meson_fbdev[%s], ret=%d\n",
		fbdev->plane->name, ret);
	return ret;
}

static int am_meson_drm_fbdev_ioctl(struct fb_info *info,
				    unsigned int cmd, unsigned long arg)
{
	int ret = 0, i = 0;
	u32 val;
	void __user *argp = (void __user *)arg;
	struct fb_dmabuf_export fbdma;
	struct drm_fb_helper *helper = info->par;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct drm_plane *plane = fbdev->plane;
	struct am_meson_fb *meson_fb;
	struct region dst = {0};
	u32 zorder = 0;

	memset(&fbdma, 0, sizeof(fbdma));
	MESON_DRM_FBDEV("CMD [%x] - [%d] IN\n", cmd, plane->index);

	/*amlogic fbdev ioctl, used by gpu fbdev backend.*/
	if (cmd == FBIOGET_OSD_DMABUF) {
		meson_fb = container_of(helper->fb, struct am_meson_fb, base);
		fbdma.fd = dma_buf_fd(meson_fb->bufp[0]->dmabuf, O_CLOEXEC);
		fbdma.flags = O_CLOEXEC;
		dma_buf_get(fbdma.fd);
		ret = copy_to_user(argp, &fbdma, sizeof(fbdma)) ? -EFAULT : 0;
	} else if (cmd == FBIO_WAITFORVSYNC) {
		am_meson_drm_wait_one_vblank(info);

		val = meson_drm_read_reg(rdma_chk_addr[plane->index]);

		while (i < MAX_RETRY_CNT && val != frame_seq[plane->index]) {
			usleep_range(2000, 2500);
			i++;
			val = meson_drm_read_reg(rdma_chk_addr[plane->index]);
		}

		if (i == MAX_RETRY_CNT)
			DRM_ERROR("timeout, frame seq %u-%u\n",
				  frame_seq[plane->index], val);

		MESON_DRM_FBDEV("wait for vsync last for %d ms, %u-%u\n", i * 2,
			  frame_seq[plane->index], val);
	} else if (cmd == FBIOSET_OSD_DST_RESOLUTION) {
		ret = copy_from_user(&dst, argp, sizeof(struct region)) ? -EFAULT : 0;
		if (ret) {
			DRM_ERROR("set dst region error and not change\n");
			memset(&fbdev->dst_changed, 0, sizeof(struct region));
		} else if ((dst.w == 0) || (dst.h == 0)) {
			MESON_DRM_FBDEV("restore mode resolution by clearing w(%d) or h(%d)\n",
				dst.w, dst.h);
			memset(&fbdev->dst_changed, 0, sizeof(struct region));
		} else {
			MESON_DRM_FBDEV("set dst region is [%d, %d, %d x %d]\n",
				dst.x, dst.y, dst.w, dst.h);
			memcpy(&fbdev->dst_changed, &dst, sizeof(struct region));
		}
	} else if (cmd == FBIOGET_OSD_ZORDER) {
		zorder = fbdev->zorder;
		ret = copy_to_user(argp, &zorder, sizeof(zorder)) ? -EFAULT : 0;
		MESON_DRM_FBDEV("get plane %d zorder and value is%d(%d)\n",
			plane->index, zorder, fbdev->zorder);
	} else if (cmd == FBIOSET_OSD_ZORDER) {
		ret = copy_from_user(&zorder, argp, sizeof(zorder)) ? -EFAULT : 0;
		if (ret) {
			DRM_ERROR("set plane %d zorder error and not change\n",
				plane->index);
		} else if ((zorder < 65) || (zorder > 128)) {
			DRM_ERROR("plane %d zorder value %d is out of range\n",
				plane->index, zorder);
			ret = -EFAULT;
		} else {
			MESON_DRM_FBDEV("set plane %d zorder and value is %d\n",
				plane->index, zorder);
			fbdev->zorder = zorder;
			ret = am_meson_drm_fb_pan_display(&info->var, info);
		}
	} else {
		DRM_ERROR("invalid fbdev ioctl cmd[%x]\n", cmd);
		ret = -EFAULT;
	}

	MESON_DRM_FBDEV("CMD [%x] - [%d] OUT\n", cmd, plane->index);
	return ret;
}

static struct fb_ops meson_drm_fbdev_ops = {
	.owner		= THIS_MODULE,
	.fb_open        = am_meson_fbdev_open,
	.fb_release     = am_meson_fbdev_release,
	.fb_mmap	= am_meson_fbdev_mmap,
	__FB_DEFAULT_DMAMEM_OPS_DRAW,
	.fb_check_var	= am_meson_drm_fb_helper_check_var,
	.fb_set_par	= am_meson_drm_fb_helper_set_par,
	.fb_blank	= am_meson_drm_fb_blank,
	.fb_pan_display	= am_meson_drm_fb_pan_display,
	.fb_setcmap	= am_meson_drm_fbdev_setcmap,
	.fb_setcolreg   = am_meson_drm_fbdev_setcolreg,
	.fb_sync	= am_meson_drm_fbdev_sync,
	.fb_ioctl       = am_meson_drm_fbdev_ioctl,
#ifdef CONFIG_COMPAT
	.fb_compat_ioctl = am_meson_drm_fbdev_ioctl,
#endif
};

static int am_meson_drm_fbdev_modeset_create(struct drm_fb_helper *helper)
{
	struct drm_device *dev = helper->dev;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct am_osd_plane *amp = to_am_osd_plane(fbdev->plane);
	struct meson_drm *private = dev->dev_private;
	int crtc_id = private->of_conf.crtcmask_osd[amp->plane_index];

	fbdev->modeset.crtc = drm_crtc_from_index(dev, crtc_id);
	DRM_INFO("%s in, plane_index = %d, crtc_id = %d\n",
		__func__, amp->plane_index, crtc_id);

	return 0;
}

static int am_meson_drm_fbdev_probe(struct drm_fb_helper *helper,
				     struct drm_fb_helper_surface_size *sizesxx)
{
	struct drm_device *dev = helper->dev;
	struct meson_drm *private = dev->dev_private;
	struct meson_drm_fbdev *fbdev = container_of(helper, struct meson_drm_fbdev, base);
	struct drm_mode_fb_cmd2 mode_cmd = { 0 };
	struct drm_fb_helper_surface_size sizes;
	struct drm_framebuffer *fb;
	struct fb_info *fbi;
	unsigned int bytes_per_pixel;
	int ret;

	if (private->ui_config.overlay_flag == 1) {
		sizes.fb_width = private->ui_config.overlay_ui_w;
		sizes.fb_height = private->ui_config.overlay_ui_h;
		sizes.surface_width = private->ui_config.overlay_fb_w;
		sizes.surface_height = private->ui_config.overlay_fb_h;
		sizes.surface_bpp = private->ui_config.overlay_fb_bpp;
	} else {
		sizes.fb_width = private->ui_config.ui_w;
		sizes.fb_height = private->ui_config.ui_h;
		sizes.surface_width = private->ui_config.fb_w;
		sizes.surface_height = private->ui_config.fb_h;
		sizes.surface_bpp = private->ui_config.fb_bpp;
	}

	sizes.surface_depth = PREFERRED_DEPTH;

	bytes_per_pixel = DIV_ROUND_UP(sizes.surface_bpp, 8);
	mode_cmd.width = sizes.surface_width;
	mode_cmd.height = sizes.surface_height;
	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes.surface_bpp, PREFERRED_DEPTH);
	mode_cmd.pitches[0] = ALIGN(mode_cmd.width * bytes_per_pixel, 64);

	DRM_INFO("fb=%dx%d, surface=%dx%d, bpp=%d\n",
		sizes.fb_width, sizes.fb_height, sizes.surface_width,
		sizes.surface_height, sizes.surface_bpp);
	DRM_INFO("mode_cmd_size=%dx%d,pixel_format=%d-%d-%d,pitches=%d,fb_gem=%p\n",
		mode_cmd.width, mode_cmd.height, mode_cmd.pixel_format,
		DRM_FORMAT_ARGB8888, DRM_FORMAT_ABGR8888,
		mode_cmd.pitches[0], fbdev->fb_gem);

	fbi = drm_fb_helper_alloc_info(helper);
	if (IS_ERR(fbi)) {
		DRM_ERROR("Failed to create framebuffer info.\n");
		ret = PTR_ERR(fbi);
		return ret;
	}

	helper->fb = am_meson_drm_framebuffer_init(dev, &mode_cmd,
						   fbdev->fb_gem);
	if (IS_ERR(helper->fb)) {
		dev_err(dev->dev, "Failed to allocate DRM framebuffer.\n");
		ret = PTR_ERR(helper->fb);
		goto err_release_fbi;
	}
	fb = helper->fb;

	fbi->par = helper;
	fbi->fbops = &meson_drm_fbdev_ops;
	fbi->skip_vt_switch = true;
	fbi->screen_size = fb->pitches[0] * fb->height;
	fbi->fix.smem_len = fbi->screen_size;

	drm_fb_helper_fill_info(fbi, helper, &sizes);
	am_meson_drm_fbdev_modeset_create(helper);

	DRM_INFO("xres=%dx%d, xres_virtual=%dx%d, bpp=%d, screen_size=%ld\n",
		fbi->var.xres, fbi->var.yres,
		fbi->var.xres_virtual, fbi->var.yres_virtual,
		fbi->var.bits_per_pixel, fbi->screen_size);
	return 0;

err_release_fbi:
	drm_fb_helper_fini(helper);
	return ret;
}

static const struct drm_fb_helper_funcs meson_drm_fb_helper_funcs = {
	.fb_probe = am_meson_drm_fbdev_probe,
};

static int am_meson_fbdev_parse_config(struct drm_device *dev)
{
	struct meson_drm *private = dev->dev_private;
	struct meson_vpu_pipeline *pipeline = private->pipeline;
	u32 sizes[5], overlay_sizes[5];
	int ret, tmp, i;

	ret = of_property_read_u32_array(dev->dev->of_node,
				   "fbdev_sizes", sizes, 5);
	tmp = of_property_read_u32_array(dev->dev->of_node,
				   "fbdev_overlay_sizes", overlay_sizes, 5);
	if (!ret) {
		private->ui_config.ui_w = sizes[0];
		private->ui_config.ui_h = sizes[1];
		private->ui_config.fb_w = sizes[2];
		private->ui_config.fb_h = sizes[3];
		private->ui_config.fb_bpp = sizes[4];
		private->ui_config.overlay_ui_w = sizes[0];
		private->ui_config.overlay_ui_h = sizes[1];
		private->ui_config.overlay_fb_w = sizes[2];
		private->ui_config.overlay_fb_h = sizes[3];
		private->ui_config.overlay_fb_bpp = sizes[4];
	}
	if (!tmp) {
		private->ui_config.overlay_ui_w = overlay_sizes[0];
		private->ui_config.overlay_ui_h = overlay_sizes[1];
		private->ui_config.overlay_fb_w = overlay_sizes[2];
		private->ui_config.overlay_fb_h = overlay_sizes[3];
		private->ui_config.overlay_fb_bpp = overlay_sizes[4];
	}
	/*initial fbdev zorder*/
	for (i = 0; i < MESON_MAX_OSD; i++)
		private->fbdev_zorder[i] = i;

	tmp = of_property_read_u32_array(dev->dev->of_node, "fbdev_zorder",
		private->fbdev_zorder, pipeline->num_osds);
	if (tmp)
		MESON_DRM_FBDEV("undefined fbdev_zorder!\n");

	return ret;
}

static ssize_t show_force_free_mem(struct device *device,
		struct device_attribute *attr, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "Usage: echo 1 > force_free mem\n");
}

static ssize_t store_force_free_mem(struct device *device,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct fb_info *fb_info = dev_get_drvdata(device);

	if (strncmp("1", buf, 1) == 0) {
		am_meson_fbdev_free_fb_gem(fb_info);
		DRM_INFO("fb mem is freed !\n");
	}
	return count;
}

static struct device_attribute fbdev_device_attrs[] = {
	__ATTR(force_free_mem, 0644, show_force_free_mem, store_force_free_mem),
};

struct meson_drm_fbdev *am_meson_create_drm_fbdev(struct drm_device *dev,
					    struct drm_plane *plane)
{
	struct meson_drm *drmdev = dev->dev_private;
	struct meson_drm_fbdev *fbdev;
	struct drm_fb_helper *helper;
	int ret, bpp;
	struct fb_info *fbinfo;
	int i = 0;

	bpp = drmdev->ui_config.fb_bpp;
	fbdev = devm_kzalloc(dev->dev, sizeof(struct meson_drm_fbdev), GFP_KERNEL);
	if (!fbdev)
		return NULL;

	helper = &fbdev->base;

	if (plane)
		fbdev->plane = plane;
	else
		return NULL;

	drm_fb_helper_prepare(dev, helper,  bpp, &meson_drm_fb_helper_funcs);

	ret = drm_fb_helper_init(dev, helper);
	if (ret < 0) {
		dev_err(dev->dev, "Failed to initialize drm fb helper - %d.\n",
			ret);
		goto err_free;
	}

	ret = drm_fb_helper_initial_config(helper);
	if (ret < 0) {
		dev_err(dev->dev, "Failed to set initial hw config - %d.\n",
			ret);
		goto err_drm_fb_helper_fini;
	}

	fbinfo = helper->info;
	if (fbinfo && fbinfo->dev) {
		for (i = 0; i < ARRAY_SIZE(fbdev_device_attrs); i++) {
			ret = device_create_file(fbinfo->dev,
						&fbdev_device_attrs[i]);
			if (ret) {
				DRM_ERROR("Failed to create file - %d.\n", ret);
				continue;
			}
		}
		fbinfo->flags &= ~FBINFO_HIDE_SMEM_START;
	}

	fbdev->blank = false;
	fbdev->vscreen_info_changed = false;

	DRM_INFO("create fbdev success.\n");
	return fbdev;

err_drm_fb_helper_fini:
	drm_fb_helper_fini(helper);
err_free:
	kfree(fbdev);
	fbdev = NULL;
	DRM_INFO("create drm fbdev failed[%d]\n", ret);
	return NULL;
}

int am_meson_drm_fbdev_init(struct drm_device *dev)
{
	struct meson_drm *drmdev = dev->dev_private;
	struct meson_drm_fbdev *fbdev;
	struct am_osd_plane *osd_plane;
	int i, fbdev_cnt = 0;
	int ret = 0;

	DRM_INFO("%s in\n", __func__);

	ret = am_meson_fbdev_parse_config(dev);
	if (ret) {
		DRM_ERROR("don't find fbdev_sizes, please config it\n");
		return ret;
	}

	if (drmdev->primary_plane) {
		drmdev->ui_config.overlay_flag = 0;
		fbdev = am_meson_create_drm_fbdev(dev, drmdev->primary_plane);
		if (fbdev) {
			fbdev->zorder = OSD_PLANE_BEGIN_ZORDER + drmdev->fbdev_zorder[0];
			fbdev_cnt++;
			MESON_DRM_FBDEV("create fbdev(%p) for primary plane, zorder=(%d %d)\n",
				fbdev, drmdev->fbdev_zorder[i], fbdev->zorder);
		} else {
			DRM_ERROR("create fbdev for primary plane failed\n");
		}
	}

	/*only create fbdev for viu1*/
	for (i = 0; i < MESON_MAX_OSD; i++) {
		osd_plane = drmdev->osd_planes[i];
		if (!osd_plane)
			continue;

		if (osd_plane->base.type == DRM_PLANE_TYPE_PRIMARY)
			continue;

		drmdev->ui_config.overlay_flag = 1;
		fbdev = am_meson_create_drm_fbdev(dev, &osd_plane->base);
		if (fbdev) {
			fbdev->zorder = OSD_PLANE_BEGIN_ZORDER + drmdev->fbdev_zorder[i];
			fbdev_cnt++;
			MESON_DRM_FBDEV("create fbdev(%p) for plane (%d %d), zorder=(%d %d)\n",
				fbdev, i, osd_plane->plane_index,
				drmdev->fbdev_zorder[i], fbdev->zorder);
		} else {
			DRM_ERROR("create fbdev for plane %d failed\n", i);
			break;
		}
	}

	DRM_INFO("%s create %d out\n", __func__, fbdev_cnt);
	return 0;
}

void am_meson_drm_fbdev_fini(struct drm_device *dev)
{
	struct meson_drm *private = dev->dev_private;
	struct meson_drm_fbdev *fbdev;
	struct drm_fb_helper *helper;
	struct fb_info *fbinfo;
	int i;

	for (i = 0; i < MESON_MAX_OSD; i++) {
		fbdev = private->osd_fbdevs[i];
		if (!fbdev) {
			dev_err(dev->dev, "fbdev is NULL.\n");
			continue;
		}

		helper = &fbdev->base;
		if (!helper || !helper->info) {
			kfree(fbdev);
			dev_err(dev->dev, "helper or fbinfo is NULL.\n");
			continue;
		}

		fbinfo = helper->info;
		if (fbinfo && fbinfo->dev) {
			for (i = 0; i < ARRAY_SIZE(fbdev_device_attrs); i++) {
				device_remove_file(fbinfo->dev,
						&fbdev_device_attrs[i]);
			}
		}

		drm_fb_helper_unregister_info(helper);
		drm_fb_helper_fini(helper);
		if (helper->fb)
			drm_framebuffer_put(helper->fb);
		fbdev->fb_gem = NULL;
		drm_fb_helper_fini(helper);
		kfree(fbdev);
	}
}