/*
 * Copyright 2017-2018 NXP
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 */

#include <drm/drmP.h>
#include <drm/drm_plane_helper.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drm_atomic.h>
#include <linux/dma-buf.h>

#include "video/imx-dcss.h"
#include "video/viv-metadata.h"
#include "dcss-plane.h"
#include "dcss-crtc.h"

static const u32 dcss_common_formats[] = {
	/* RGB */
	DRM_FORMAT_ARGB8888,
	DRM_FORMAT_XRGB8888,
	DRM_FORMAT_ABGR8888,
	DRM_FORMAT_XBGR8888,
	DRM_FORMAT_RGBA8888,
	DRM_FORMAT_RGBX8888,
	DRM_FORMAT_BGRA8888,
	DRM_FORMAT_BGRX8888,
	DRM_FORMAT_XRGB2101010,
	DRM_FORMAT_XBGR2101010,
	DRM_FORMAT_RGBX1010102,
	DRM_FORMAT_BGRX1010102,
	DRM_FORMAT_ARGB2101010,
	DRM_FORMAT_ABGR2101010,
	DRM_FORMAT_RGBA1010102,
	DRM_FORMAT_BGRA1010102,

	/* YUV444 */
	DRM_FORMAT_AYUV,

	/* YUV422 */
	DRM_FORMAT_UYVY,
	DRM_FORMAT_VYUY,
	DRM_FORMAT_YUYV,
	DRM_FORMAT_YVYU,

	/* YUV420 */
	DRM_FORMAT_NV12,
	DRM_FORMAT_NV21,
	DRM_FORMAT_P010,
};

static const u64 dcss_video_format_modifiers[] = {
	DRM_FORMAT_MOD_VSI_G1_TILED,
	DRM_FORMAT_MOD_VSI_G2_TILED,
	DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED,
	DRM_FORMAT_MOD_LINEAR,
	DRM_FORMAT_MOD_INVALID,
};

static const u64 dcss_graphics_format_modifiers[] = {
	DRM_FORMAT_MOD_VIVANTE_TILED,
	DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
	DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC,
	DRM_FORMAT_MOD_LINEAR,
	DRM_FORMAT_MOD_INVALID,
};

static inline struct dcss_plane *to_dcss_plane(struct drm_plane *p)
{
	return container_of(p, struct dcss_plane, base);
}

static void dcss_plane_destroy(struct drm_plane *plane)
{
	struct dcss_plane *dcss_plane = container_of(plane, struct dcss_plane,
						     base);

	DRM_DEBUG_KMS("destroy plane\n");

	drm_plane_cleanup(plane);
	kfree(dcss_plane);
}

static int dcss_plane_atomic_set_property(struct drm_plane *plane,
					  struct drm_plane_state *state,
					  struct drm_property *property,
					  uint64_t val)
{
	struct dcss_plane *dcss_plane = to_dcss_plane(plane);

	if (property == dcss_plane->alpha_prop)
		dcss_plane->alpha_val = val;
	else if (property == dcss_plane->use_global_prop)
		dcss_plane->use_global_val = val;
	else if (property == dcss_plane->dtrc_table_ofs_prop)
		dcss_plane->dtrc_table_ofs_val = val;
	else
		return -EINVAL;

	return 0;
}

static int dcss_plane_atomic_get_property(struct drm_plane *plane,
					  const struct drm_plane_state *state,
					  struct drm_property *property,
					  uint64_t *val)
{
	struct dcss_plane *dcss_plane = to_dcss_plane(plane);

	if (property == dcss_plane->alpha_prop)
		*val = dcss_plane->alpha_val;
	else if (property == dcss_plane->use_global_prop)
		*val = dcss_plane->use_global_val;
	else if (property == dcss_plane->dtrc_table_ofs_prop)
		*val = dcss_plane->dtrc_table_ofs_val;
	else
		return -EINVAL;

	return 0;
}

static bool dcss_plane_format_mod_supported(struct drm_plane *plane,
					    uint32_t format,
					    uint64_t modifier)
{
	switch (plane->type) {
	case DRM_PLANE_TYPE_PRIMARY:
		switch (format) {
		case DRM_FORMAT_ARGB8888:
		case DRM_FORMAT_XRGB8888:
		case DRM_FORMAT_ARGB2101010:
			return modifier == DRM_FORMAT_MOD_LINEAR ||
			       modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
			       modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED ||
			       modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC;
		default:
			return modifier == DRM_FORMAT_MOD_LINEAR;
		}
		break;
	case DRM_PLANE_TYPE_OVERLAY:
		switch (format) {
		case DRM_FORMAT_NV12:
		case DRM_FORMAT_NV21:
		case DRM_FORMAT_P010:
			return modifier == DRM_FORMAT_MOD_LINEAR ||
			       modifier == DRM_FORMAT_MOD_VSI_G1_TILED ||
			       modifier == DRM_FORMAT_MOD_VSI_G2_TILED ||
			       modifier == DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED;
		default:
			return modifier == DRM_FORMAT_MOD_LINEAR;
		}
		break;
	default:
		return false;
	}
}

static const struct drm_plane_funcs dcss_plane_funcs = {
	.update_plane	= drm_atomic_helper_update_plane,
	.disable_plane	= drm_atomic_helper_disable_plane,
	.destroy	= dcss_plane_destroy,
	.reset		= drm_atomic_helper_plane_reset,
	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
	.atomic_set_property = dcss_plane_atomic_set_property,
	.atomic_get_property = dcss_plane_atomic_get_property,
	.format_mod_supported = dcss_plane_format_mod_supported,
};

static bool dcss_plane_can_rotate(u32 pixel_format, bool mod_present,
				  u64 modifier, unsigned int rotation)
{
	enum dcss_color_space cs = dcss_drm_fourcc_to_colorspace(pixel_format);
	bool linear_format = !mod_present ||
			     (mod_present && modifier == DRM_FORMAT_MOD_LINEAR);
	u32 supported_rotation = DRM_MODE_ROTATE_0;

	if (cs == DCSS_COLORSPACE_RGB && linear_format)
		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
				     DRM_MODE_REFLECT_MASK;
	else if (cs == DCSS_COLORSPACE_RGB &&
		 modifier == DRM_FORMAT_MOD_VIVANTE_TILED)
		supported_rotation = DRM_MODE_ROTATE_MASK |
				     DRM_MODE_REFLECT_MASK;
	else if (cs == DCSS_COLORSPACE_RGB &&
		 modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC)
		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
				     DRM_MODE_REFLECT_MASK;
	else if (cs == DCSS_COLORSPACE_YUV && linear_format &&
		 (pixel_format == DRM_FORMAT_NV12 ||
		 pixel_format == DRM_FORMAT_NV21))
		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
				     DRM_MODE_REFLECT_MASK;
	else if (cs == DCSS_COLORSPACE_YUV && linear_format &&
		 pixel_format == DRM_FORMAT_P010)
		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_REFLECT_Y;

	return !!(rotation & supported_rotation);
}

static bool dcss_plane_is_source_size_allowed(u16 src_w, u16 src_h, u32 pix_fmt)
{
	if (src_w < 64 &&
	    (pix_fmt == DRM_FORMAT_NV12 || pix_fmt == DRM_FORMAT_NV21 ||
	     pix_fmt == DRM_FORMAT_P010))
		return false;
	else if (src_w < 32 &&
		 (pix_fmt == DRM_FORMAT_UYVY || pix_fmt == DRM_FORMAT_VYUY ||
		  pix_fmt == DRM_FORMAT_YUYV || pix_fmt == DRM_FORMAT_YVYU))
		return false;

	return src_w >= 16 && src_h >= 8;
}

static int dcss_plane_atomic_check(struct drm_plane *plane,
				   struct drm_plane_state *state)
{
	struct dcss_plane *dcss_plane = to_dcss_plane(plane);
	struct drm_framebuffer *fb = state->fb;
	struct drm_gem_cma_object *cma_obj;
	struct drm_crtc_state *crtc_state;
	int hdisplay, vdisplay;
	struct drm_rect crtc_rect, disp_rect;

	if (!fb || !state->crtc)
		return 0;

	cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
	WARN_ON(!cma_obj);

	crtc_state = drm_atomic_get_existing_crtc_state(state->state,
							state->crtc);

	hdisplay = crtc_state->adjusted_mode.hdisplay;
	vdisplay = crtc_state->adjusted_mode.vdisplay;

	crtc_rect.x1 = state->crtc_x;
	crtc_rect.x2 = state->crtc_x + state->crtc_w;
	crtc_rect.y1 = state->crtc_y;
	crtc_rect.y2 = state->crtc_y + state->crtc_h;

	disp_rect.x1 = 0;
	disp_rect.y1 = 0;
	disp_rect.x2 = hdisplay;
	disp_rect.y2 = vdisplay;

	if (!dcss_plane_is_source_size_allowed(state->src_w >> 16,
					       state->src_h >> 16,
					       fb->format->format)) {
		DRM_DEBUG_KMS("Source plane size is not allowed!\n");
		return -EINVAL;
	}

	/* make sure the crtc is visible */
	if (!drm_rect_intersect(&crtc_rect, &disp_rect)) {
		state->visible = false;
		return 0;
	}

	state->visible = true;

	if (!dcss_plane_can_rotate(fb->format->format,
				   !!(fb->flags & DRM_MODE_FB_MODIFIERS),
				   fb->modifier,
				   state->rotation)) {
		DRM_ERROR("requested rotation is not allowed!\n");
		return -EINVAL;
	}

	/* cropping is only available on overlay planes when DTRC is used */
	if (state->crtc_x < 0 || state->crtc_y < 0 ||
	    state->crtc_x + state->crtc_w > hdisplay ||
	    state->crtc_y + state->crtc_h > vdisplay) {
		if (plane->type == DRM_PLANE_TYPE_PRIMARY)
			return -EINVAL;
		else if (!(fb->flags & DRM_MODE_FB_MODIFIERS) ||
			 (fb->flags & DRM_MODE_FB_MODIFIERS &&
			  fb->modifier == DRM_FORMAT_MOD_LINEAR))
			return -EINVAL;
	}

	if (!dcss_scaler_can_scale(dcss_plane->dcss, dcss_plane->ch_num,
				   state->src_w >> 16, state->src_h >> 16,
				   state->crtc_w, state->crtc_h)) {
		DRM_DEBUG_KMS("Invalid upscale/downscale ratio.");
		return -EINVAL;
	}

	if ((fb->flags & DRM_MODE_FB_MODIFIERS) &&
	    !plane->funcs->format_mod_supported(plane,
				fb->format->format,
				fb->modifier)) {
		DRM_INFO("Invalid modifier: %llx", fb->modifier);
		return -EINVAL;
	}

	return 0;
}

static struct drm_gem_object *dcss_plane_gem_import(struct drm_device *dev,
						    struct dma_buf *dma_buf)
{
	struct drm_gem_object *obj;

	if (IS_ERR(dma_buf))
		return ERR_CAST(dma_buf);

	mutex_lock(&dev->object_name_lock);

	obj = dev->driver->gem_prime_import(dev, dma_buf);

	mutex_unlock(&dev->object_name_lock);

	return obj;
}

static void dcss_plane_atomic_set_base(struct dcss_plane *dcss_plane)
{
	int mod_idx;
	struct drm_plane *plane = &dcss_plane->base;
	struct drm_plane_state *state = plane->state;
	struct drm_framebuffer *fb = state->fb;
	struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
	unsigned long p1_ba, p2_ba;
	dma_addr_t caddr;
	bool modifiers_present = !!(fb->flags & DRM_MODE_FB_MODIFIERS);
	u32 pix_format = state->fb->format->format;
	bool compressed = true;
	uint32_t compressed_format = 0;

	BUG_ON(!cma_obj);

	p1_ba = cma_obj->paddr + fb->offsets[0] +
		fb->pitches[0] * (state->src_y >> 16) +
		fb->format->cpp[0] * (state->src_x >> 16);

	p2_ba = cma_obj->paddr + fb->offsets[1] +
		fb->pitches[1] * (state->src_y >> 16) +
		fb->format->cpp[0] * (state->src_x >> 16);

	dcss_dpr_addr_set(dcss_plane->dcss, dcss_plane->ch_num, p1_ba, p2_ba,
			  fb->pitches[0]);

	switch (plane->type) {
	case DRM_PLANE_TYPE_PRIMARY:
		if (!modifiers_present) {
			/* No modifier: bypass dec400d */
			dcss_dec400d_bypass(dcss_plane->dcss);
			return;
		}

		for (mod_idx = 0; mod_idx < 4; mod_idx++)
			dcss_dec400d_set_format_mod(dcss_plane->dcss,
					pix_format,
					mod_idx,
					fb->modifier);

		switch (fb->modifier) {
		case DRM_FORMAT_MOD_LINEAR:
		case DRM_FORMAT_MOD_VIVANTE_TILED:
		case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
			/* Bypass dec400d */
			dcss_dec400d_bypass(dcss_plane->dcss);
			return;
		case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC:
			do {
				struct dma_buf *dma_buf = cma_obj->base.dma_buf;
				struct drm_gem_object *gem_obj;
					_VIV_VIDMEM_METADATA *mdata;

				if (!dma_buf) {
					caddr = cma_obj->paddr + ALIGN(fb->height, 64) * fb->pitches[0];
					break;
				}

				mdata = dma_buf->priv;
				if (!mdata || mdata->magic != VIV_VIDMEM_METADATA_MAGIC) {
					return;
				}
				compressed = mdata->compressed ? true : false;
				compressed_format = mdata->compress_format;

				gem_obj = dcss_plane_gem_import(plane->dev, mdata->ts_dma_buf);
				if (IS_ERR(gem_obj)) {
					return;
				}

				caddr = to_drm_gem_cma_obj(gem_obj)->paddr;

				/* release gem_obj */
				drm_gem_object_unreference_unlocked(gem_obj);

				dcss_dec400d_fast_clear_config(dcss_plane->dcss,
						mdata->fc_value,
						mdata->fc_enabled);
			} while (0);
			dcss_dec400d_read_config(dcss_plane->dcss, 0, compressed, compressed_format);
			dcss_dec400d_addr_set(dcss_plane->dcss, p1_ba, caddr);
			break;
		default:
			WARN_ON(1);
			return;
		}

		break;
	case DRM_PLANE_TYPE_OVERLAY:
		if (!modifiers_present ||
		    (modifiers_present && fb->modifier == DRM_FORMAT_MOD_LINEAR) ||
		    (pix_format != DRM_FORMAT_NV12 &&
		     pix_format != DRM_FORMAT_NV21 &&
		     pix_format != DRM_FORMAT_P010)) {
			dcss_dtrc_bypass(dcss_plane->dcss, dcss_plane->ch_num);
			return;
		}

		dcss_dtrc_set_format_mod(dcss_plane->dcss, dcss_plane->ch_num,
					 fb->modifier);
		dcss_dtrc_addr_set(dcss_plane->dcss, dcss_plane->ch_num,
				   p1_ba, p2_ba, dcss_plane->dtrc_table_ofs_val);
		break;
	default:
		WARN_ON(1);
		return;
	}
}

static bool dcss_plane_needs_setup(struct drm_plane_state *state,
				   struct drm_plane_state *old_state)
{
	struct drm_framebuffer *fb = state->fb;
	struct drm_framebuffer *old_fb = old_state->fb;

	return state->crtc_x != old_state->crtc_x ||
	       state->crtc_y != old_state->crtc_y ||
	       state->crtc_w != old_state->crtc_w ||
	       state->crtc_h != old_state->crtc_h ||
	       state->src_x  != old_state->src_x  ||
	       state->src_y  != old_state->src_y  ||
	       state->src_w  != old_state->src_w  ||
	       state->src_h  != old_state->src_h  ||
	       fb->format->format != old_fb->format->format ||
	       fb->modifier  != old_fb->modifier ||
	       state->rotation != old_state->rotation;
}

static void dcss_plane_adjust(struct drm_rect *dis_rect,
			      struct drm_rect *crtc,
			      struct drm_rect *src)
{
	struct drm_rect new_crtc = *dis_rect, new_src;
	u32 hscale, vscale;

	hscale = ((src->x2 - src->x1) << 16) / (crtc->x2 - crtc->x1);
	vscale = ((src->y2 - src->y1) << 16) / (crtc->y2 - crtc->y1);

	drm_rect_intersect(&new_crtc, crtc);

	new_src.x1 = ((new_crtc.x1 - crtc->x1) * hscale + (1 << 15)) >> 16;
	new_src.x2 = ((new_crtc.x2 - crtc->x1) * hscale + (1 << 15)) >> 16;
	new_src.y1 = ((new_crtc.y1 - crtc->y1) * vscale + (1 << 15)) >> 16;
	new_src.y2 = ((new_crtc.y2 - crtc->y1) * vscale + (1 << 15)) >> 16;

	*crtc = new_crtc;
	*src = new_src;
}

static bool dcss_plane_format_has_alpha_channel(u32 pix_format)
{
	return pix_format == DRM_FORMAT_ARGB8888 ||
	       pix_format == DRM_FORMAT_ABGR8888 ||
	       pix_format == DRM_FORMAT_RGBA8888 ||
	       pix_format == DRM_FORMAT_BGRA8888 ||
	       pix_format == DRM_FORMAT_BGRA8888 ||
	       pix_format == DRM_FORMAT_ARGB2101010 ||
	       pix_format == DRM_FORMAT_ABGR2101010 ||
	       pix_format == DRM_FORMAT_RGBA1010102 ||
	       pix_format == DRM_FORMAT_BGRA1010102;
}

static void dcss_plane_atomic_update(struct drm_plane *plane,
				     struct drm_plane_state *old_state)
{
	struct drm_plane_state *state = plane->state;
	struct dcss_plane *dcss_plane = to_dcss_plane(plane);
	struct drm_framebuffer *fb = state->fb;
	u32 pixel_format;
	struct drm_crtc_state *crtc_state;
	bool modifiers_present;
	u32 src_w, src_h, adj_w, adj_h;
	struct drm_rect disp, crtc, src, old_src;
	u32 scaler_w, scaler_h;
	struct dcss_hdr10_pipe_cfg ipipe_cfg, opipe_cfg;
	bool enable = true;

	if (!fb || !state->crtc || !state->visible)
		return;

	pixel_format = state->fb->format->format;
	crtc_state = state->crtc->state;
	modifiers_present = !!(fb->flags & DRM_MODE_FB_MODIFIERS);

	if (old_state->fb && !drm_atomic_crtc_needs_modeset(crtc_state) &&
	    !dcss_plane_needs_setup(state, old_state) &&
	    !dcss_dtg_global_alpha_changed(dcss_plane->dcss, dcss_plane->ch_num,
					   pixel_format, dcss_plane->alpha_val,
					   dcss_plane->use_global_val)) {
		dcss_plane_atomic_set_base(dcss_plane);
		if (plane->type == DRM_PLANE_TYPE_PRIMARY)
			dcss_dec400d_shadow_trig(dcss_plane->dcss);
		return;
	}

	disp.x1 = 0;
	disp.y1 = 0;
	disp.x2 = crtc_state->adjusted_mode.hdisplay;
	disp.y2 = crtc_state->adjusted_mode.vdisplay;

	crtc.x1 = state->crtc_x;
	crtc.y1 = state->crtc_y;
	crtc.x2 = state->crtc_x + state->crtc_w;
	crtc.y2 = state->crtc_y + state->crtc_h;

	src.x1 = state->src_x >> 16;
	src.y1 = state->src_y >> 16;
	src.x2 = (state->src_x >> 16) + (state->src_w >> 16);
	src.y2 = (state->src_y >> 16) + (state->src_h >> 16);

	old_src = src;

	dcss_plane_adjust(&disp, &crtc, &src);

	/*
	 * The width and height after clipping, if image was partially
	 * outside the display area.
	 */
	src_w = src.x2 - src.x1;
	src_h = src.y2 - src.y1;

	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
		dcss_dtrc_set_res(dcss_plane->dcss, dcss_plane->ch_num,
				  &src, &old_src, pixel_format);

	/* DTRC has probably aligned the sizes. */
	adj_w = src.x2 - src.x1;
	adj_h = src.y2 - src.y1;

	if (plane->type == DRM_PLANE_TYPE_OVERLAY &&
	    modifiers_present && fb->modifier == DRM_FORMAT_MOD_LINEAR)
		modifiers_present = false;

	dcss_dpr_format_set(dcss_plane->dcss, dcss_plane->ch_num, pixel_format,
				modifiers_present);
	if (!modifiers_present)
		dcss_dpr_tile_derive(dcss_plane->dcss,
				     dcss_plane->ch_num,
				     DRM_FORMAT_MOD_LINEAR);
	else
		dcss_dpr_tile_derive(dcss_plane->dcss,
				     dcss_plane->ch_num,
				     fb->modifier);

	dcss_dpr_set_res(dcss_plane->dcss, dcss_plane->ch_num,
			 src_w, src_h, adj_w, adj_h);
	dcss_dpr_set_rotation(dcss_plane->dcss, dcss_plane->ch_num,
			      state->rotation);
	dcss_plane_atomic_set_base(dcss_plane);

	if (fb->modifier == DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED) {
		scaler_w = src.x1 ? adj_w : src_w;
		scaler_h = src.y1 ? adj_h : src_h;
	} else {
		scaler_w = src_w;
		scaler_h = src_h;
	}

	dcss_scaler_setup(dcss_plane->dcss, dcss_plane->ch_num,
			  pixel_format, scaler_w, scaler_h,
			  crtc.x2 - crtc.x1,
			  crtc.y2 - crtc.y1,
			  drm_mode_vrefresh(&crtc_state->mode));

	ipipe_cfg.pixel_format = pixel_format;

	dcss_crtc_get_opipe_cfg(state->crtc, &opipe_cfg);

	ipipe_cfg.nl = opipe_cfg.nl == NL_REC2084 ? NL_REC2084 : NL_REC709;
	ipipe_cfg.pr = PR_FULL;
	ipipe_cfg.g = opipe_cfg.g == G_REC2020 ? G_REC2020 : G_REC709;

	dcss_hdr10_setup(dcss_plane->dcss, dcss_plane->ch_num,
			 &ipipe_cfg, &opipe_cfg);

	dcss_dtg_plane_pos_set(dcss_plane->dcss, dcss_plane->ch_num,
			       crtc.x1, crtc.y1,
			       crtc.x2 - crtc.x1,
			       crtc.y2 - crtc.y1);
	dcss_dtg_plane_alpha_set(dcss_plane->dcss, dcss_plane->ch_num,
				 pixel_format, dcss_plane->alpha_val,
				 dcss_plane->use_global_val);

	switch (plane->type) {
	case DRM_PLANE_TYPE_PRIMARY:
		dcss_dec400d_enable(dcss_plane->dcss);
		break;
	case DRM_PLANE_TYPE_OVERLAY:
		dcss_dtrc_enable(dcss_plane->dcss, dcss_plane->ch_num, true);
		break;
	default:
		WARN_ON(1);
		break;
	}

	if (!dcss_plane->ch_num &&
	    ((dcss_plane->alpha_val == 0 &&
	    !dcss_plane_format_has_alpha_channel(pixel_format)) ||
	    (dcss_plane->alpha_val == 0 && dcss_plane->use_global_val &&
	     dcss_plane_format_has_alpha_channel(pixel_format))))
		enable = false;

	dcss_dpr_enable(dcss_plane->dcss, dcss_plane->ch_num, enable);
	dcss_scaler_enable(dcss_plane->dcss, dcss_plane->ch_num, enable);

	if (!enable)
		dcss_dtg_plane_pos_set(dcss_plane->dcss, dcss_plane->ch_num,
				       0, 0, 0, 0);

	dcss_dtg_ch_enable(dcss_plane->dcss, dcss_plane->ch_num, enable);
}

static void dcss_plane_atomic_disable(struct drm_plane *plane,
				      struct drm_plane_state *old_state)
{
	struct dcss_plane *dcss_plane = to_dcss_plane(plane);

	dcss_dtrc_enable(dcss_plane->dcss, dcss_plane->ch_num, false);
	dcss_dpr_enable(dcss_plane->dcss, dcss_plane->ch_num, false);
	dcss_scaler_enable(dcss_plane->dcss, dcss_plane->ch_num, false);
	dcss_dtg_plane_pos_set(dcss_plane->dcss, dcss_plane->ch_num,
			       0, 0, 0, 0);
	dcss_dtg_ch_enable(dcss_plane->dcss, dcss_plane->ch_num, false);
}

static const struct drm_plane_helper_funcs dcss_plane_helper_funcs = {
	.prepare_fb = drm_fb_cma_prepare_fb,
	.atomic_check = dcss_plane_atomic_check,
	.atomic_update = dcss_plane_atomic_update,
	.atomic_disable = dcss_plane_atomic_disable,
};

struct dcss_plane *dcss_plane_init(struct drm_device *drm,
				   struct dcss_soc *dcss,
				   unsigned int possible_crtcs,
				   enum drm_plane_type type,
				   unsigned int zpos)
{
	struct dcss_plane *dcss_plane;
	const u64 *format_modifiers = dcss_video_format_modifiers;
	int ret;

	if (zpos > 2)
		return ERR_PTR(-EINVAL);

	dcss_plane = kzalloc(sizeof(*dcss_plane), GFP_KERNEL);
	if (!dcss_plane) {
		DRM_ERROR("failed to allocate plane\n");
		return ERR_PTR(-ENOMEM);
	}

	dcss_plane->dcss = dcss;

	if (type == DRM_PLANE_TYPE_PRIMARY)
		format_modifiers = dcss_graphics_format_modifiers;

	ret = drm_universal_plane_init(drm, &dcss_plane->base, possible_crtcs,
				       &dcss_plane_funcs, dcss_common_formats,
				       ARRAY_SIZE(dcss_common_formats),
				       format_modifiers, type, NULL);
	if (ret) {
		DRM_ERROR("failed to initialize plane\n");
		kfree(dcss_plane);
		return ERR_PTR(ret);
	}

	if (type == DRM_PLANE_TYPE_OVERLAY)
		dcss_plane->base.hdr_supported = true;

	drm_plane_helper_add(&dcss_plane->base, &dcss_plane_helper_funcs);

	ret = drm_plane_create_zpos_immutable_property(&dcss_plane->base, zpos);
	if (ret)
		return ERR_PTR(ret);

	drm_plane_create_rotation_property(&dcss_plane->base,
					   DRM_MODE_ROTATE_0,
					   DRM_MODE_ROTATE_0   |
					   DRM_MODE_ROTATE_90  |
					   DRM_MODE_ROTATE_180 |
					   DRM_MODE_ROTATE_270 |
					   DRM_MODE_REFLECT_X  |
					   DRM_MODE_REFLECT_Y);

	dcss_plane->ch_num = 2 - zpos;
	dcss_plane->alpha_val = 255;

	return dcss_plane;
}