drivers/gpu/drm/sun4i/sun8i_vi_layer.c - third_party/linux - Git at Google

 /*
  * Copyright (C) Jernej Skrabec <jernej.skrabec@siol.net>
  *
  * 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.
  */

 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_fb_cma_helper.h>
 #include <drm/drm_gem_cma_helper.h>
 #include <drm/drm_plane_helper.h>
 #include <drm/drmP.h>

 #include "sun8i_vi_layer.h"
 #include "sun8i_mixer.h"
 #include "sun8i_vi_scaler.h"

 static void sun8i_vi_layer_enable(struct sun8i_mixer *mixer, int channel,
 				  int overlay, bool enable)
 {
 	u32 val;

 	DRM_DEBUG_DRIVER("%sabling VI channel %d overlay %d\n",
 			 enable ? "En" : "Dis", channel, overlay);

 	if (enable)
 		val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN;
 	else
 		val = 0;

 	regmap_update_bits(mixer->engine.regs,
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN, val);

 	if (enable)
 		val = SUN8I_MIXER_BLEND_PIPE_CTL_EN(channel);
 	else
 		val = 0;

 	regmap_update_bits(mixer->engine.regs,
 			   SUN8I_MIXER_BLEND_PIPE_CTL,
 			   SUN8I_MIXER_BLEND_PIPE_CTL_EN(channel), val);
 }

 static int sun8i_vi_layer_update_coord(struct sun8i_mixer *mixer, int channel,
 				       int overlay, struct drm_plane *plane)
 {
 	struct drm_plane_state *state = plane->state;
 	const struct drm_format_info *format = state->fb->format;
 	u32 src_w, src_h, dst_w, dst_h;
 	u32 outsize, insize;
 	u32 hphase, vphase;
 	bool subsampled;

 	DRM_DEBUG_DRIVER("Updating VI channel %d overlay %d\n",
 			 channel, overlay);

 	src_w = drm_rect_width(&state->src) >> 16;
 	src_h = drm_rect_height(&state->src) >> 16;
 	dst_w = drm_rect_width(&state->dst);
 	dst_h = drm_rect_height(&state->dst);

 	hphase = state->src.x1 & 0xffff;
 	vphase = state->src.y1 & 0xffff;

 	/* make coordinates dividable by subsampling factor */
 	if (format->hsub > 1) {
 		int mask, remainder;

 		mask = format->hsub - 1;
 		remainder = (state->src.x1 >> 16) & mask;
 		src_w = (src_w + remainder) & ~mask;
 		hphase += remainder << 16;
 	}

 	if (format->vsub > 1) {
 		int mask, remainder;

 		mask = format->vsub - 1;
 		remainder = (state->src.y1 >> 16) & mask;
 		src_h = (src_h + remainder) & ~mask;
 		vphase += remainder << 16;
 	}

 	insize = SUN8I_MIXER_SIZE(src_w, src_h);
 	outsize = SUN8I_MIXER_SIZE(dst_w, dst_h);

 	/* Set height and width */
 	DRM_DEBUG_DRIVER("Layer source offset X: %d Y: %d\n",
 			 (state->src.x1 >> 16) & ~(format->hsub - 1),
 			 (state->src.y1 >> 16) & ~(format->vsub - 1));
 	DRM_DEBUG_DRIVER("Layer source size W: %d H: %d\n", src_w, src_h);
 	regmap_write(mixer->engine.regs,
 		     SUN8I_MIXER_CHAN_VI_LAYER_SIZE(channel, overlay),
 		     insize);
 	regmap_write(mixer->engine.regs,
 		     SUN8I_MIXER_CHAN_VI_OVL_SIZE(channel),
 		     insize);

 	/*
 	 * Scaler must be enabled for subsampled formats, so it scales
 	 * chroma to same size as luma.
 	 */
 	subsampled = format->hsub > 1 || format->vsub > 1;

 	if (insize != outsize || subsampled || hphase || vphase) {
 		u32 hscale, vscale;

 		DRM_DEBUG_DRIVER("HW scaling is enabled\n");

 		hscale = state->src_w / state->crtc_w;
 		vscale = state->src_h / state->crtc_h;

 		sun8i_vi_scaler_setup(mixer, channel, src_w, src_h, dst_w,
 				      dst_h, hscale, vscale, hphase, vphase,
 				      format);
 		sun8i_vi_scaler_enable(mixer, channel, true);
 	} else {
 		DRM_DEBUG_DRIVER("HW scaling is not needed\n");
 		sun8i_vi_scaler_enable(mixer, channel, false);
 	}

 	/* Set base coordinates */
 	DRM_DEBUG_DRIVER("Layer destination coordinates X: %d Y: %d\n",
 			 state->dst.x1, state->dst.y1);
 	DRM_DEBUG_DRIVER("Layer destination size W: %d H: %d\n", dst_w, dst_h);
 	regmap_write(mixer->engine.regs,
 		     SUN8I_MIXER_BLEND_ATTR_COORD(channel),
 		     SUN8I_MIXER_COORD(state->dst.x1, state->dst.y1));
 	regmap_write(mixer->engine.regs,
 		     SUN8I_MIXER_BLEND_ATTR_INSIZE(channel),
 		     outsize);

 	return 0;
 }

 static int sun8i_vi_layer_update_formats(struct sun8i_mixer *mixer, int channel,
 					 int overlay, struct drm_plane *plane)
 {
 	struct drm_plane_state *state = plane->state;
 	const struct de2_fmt_info *fmt_info;
 	u32 val;

 	fmt_info = sun8i_mixer_format_info(state->fb->format->format);
 	if (!fmt_info) {
 		DRM_DEBUG_DRIVER("Invalid format\n");
 		return -EINVAL;
 	}

 	val = fmt_info->de2_fmt << SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET;
 	regmap_update_bits(mixer->engine.regs,
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK, val);

 	if (fmt_info->csc != SUN8I_CSC_MODE_OFF) {
 		sun8i_csc_set_ccsc_coefficients(mixer, channel, fmt_info->csc);
 		sun8i_csc_enable_ccsc(mixer, channel, true);
 	} else {
 		sun8i_csc_enable_ccsc(mixer, channel, false);
 	}

 	if (fmt_info->rgb)
 		val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE;
 	else
 		val = 0;

 	regmap_update_bits(mixer->engine.regs,
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
 			   SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE, val);

 	return 0;
 }

 static int sun8i_vi_layer_update_buffer(struct sun8i_mixer *mixer, int channel,
 					int overlay, struct drm_plane *plane)
 {
 	struct drm_plane_state *state = plane->state;
 	struct drm_framebuffer *fb = state->fb;
 	const struct drm_format_info *format = fb->format;
 	struct drm_gem_cma_object *gem;
 	u32 dx, dy, src_x, src_y;
 	dma_addr_t paddr;
 	int i;

 	/* Adjust x and y to be dividable by subsampling factor */
 	src_x = (state->src.x1 >> 16) & ~(format->hsub - 1);
 	src_y = (state->src.y1 >> 16) & ~(format->vsub - 1);

 	for (i = 0; i < format->num_planes; i++) {
 		/* Get the physical address of the buffer in memory */
 		gem = drm_fb_cma_get_gem_obj(fb, i);

 		DRM_DEBUG_DRIVER("Using GEM @ %pad\n", &gem->paddr);

 		/* Compute the start of the displayed memory */
 		paddr = gem->paddr + fb->offsets[i];

 		dx = src_x;
 		dy = src_y;

 		if (i > 0) {
 			dx /= format->hsub;
 			dy /= format->vsub;
 		}

 		/* Fixup framebuffer address for src coordinates */
 		paddr += dx * format->cpp[i];
 		paddr += dy * fb->pitches[i];

 		/* Set the line width */
 		DRM_DEBUG_DRIVER("Layer %d. line width: %d bytes\n",
 				 i + 1, fb->pitches[i]);
 		regmap_write(mixer->engine.regs,
 			     SUN8I_MIXER_CHAN_VI_LAYER_PITCH(channel,
 							     overlay, i),
 	       fb->pitches[i]);

 		DRM_DEBUG_DRIVER("Setting %d. buffer address to %pad\n",
 				 i + 1, &paddr);

 		regmap_write(mixer->engine.regs,
 			     SUN8I_MIXER_CHAN_VI_LAYER_TOP_LADDR(channel,
 								 overlay, i),
 	       lower_32_bits(paddr));
 	}

 	return 0;
 }

 static int sun8i_vi_layer_atomic_check(struct drm_plane *plane,
 				       struct drm_plane_state *state)
 {
 	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
 	struct drm_crtc *crtc = state->crtc;
 	struct drm_crtc_state *crtc_state;
 	int min_scale, max_scale;

 	if (!crtc)
 		return 0;

 	crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc);
 	if (WARN_ON(!crtc_state))
 		return -EINVAL;

 	min_scale = DRM_PLANE_HELPER_NO_SCALING;
 	max_scale = DRM_PLANE_HELPER_NO_SCALING;

 	if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
 		min_scale = SUN8I_VI_SCALER_SCALE_MIN;
 		max_scale = SUN8I_VI_SCALER_SCALE_MAX;
 	}

 	return drm_atomic_helper_check_plane_state(state, crtc_state,
 						   min_scale, max_scale,
 						   true, true);
 }

 static void sun8i_vi_layer_atomic_disable(struct drm_plane *plane,
 					  struct drm_plane_state *old_state)
 {
 	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
 	struct sun8i_mixer *mixer = layer->mixer;

 	sun8i_vi_layer_enable(mixer, layer->channel, layer->overlay, false);
 }

 static void sun8i_vi_layer_atomic_update(struct drm_plane *plane,
 					 struct drm_plane_state *old_state)
 {
 	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
 	struct sun8i_mixer *mixer = layer->mixer;

 	if (!plane->state->visible) {
 		sun8i_vi_layer_enable(mixer, layer->channel,
 				      layer->overlay, false);
 		return;
 	}

 	sun8i_vi_layer_update_coord(mixer, layer->channel,
 				    layer->overlay, plane);
 	sun8i_vi_layer_update_formats(mixer, layer->channel,
 				      layer->overlay, plane);
 	sun8i_vi_layer_update_buffer(mixer, layer->channel,
 				     layer->overlay, plane);
 	sun8i_vi_layer_enable(mixer, layer->channel, layer->overlay, true);
 }

 static struct drm_plane_helper_funcs sun8i_vi_layer_helper_funcs = {
 	.atomic_check	= sun8i_vi_layer_atomic_check,
 	.atomic_disable	= sun8i_vi_layer_atomic_disable,
 	.atomic_update	= sun8i_vi_layer_atomic_update,
 };

 static const struct drm_plane_funcs sun8i_vi_layer_funcs = {
 	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
 	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
 	.destroy		= drm_plane_cleanup,
 	.disable_plane		= drm_atomic_helper_disable_plane,
 	.reset			= drm_atomic_helper_plane_reset,
 	.update_plane		= drm_atomic_helper_update_plane,
 };

 /*
  * While all RGB formats are supported, VI planes don't support
  * alpha blending, so there is no point having formats with alpha
  * channel if their opaque analog exist.
  */
 static const u32 sun8i_vi_layer_formats[] = {
 	DRM_FORMAT_ABGR1555,
 	DRM_FORMAT_ABGR4444,
 	DRM_FORMAT_ARGB1555,
 	DRM_FORMAT_ARGB4444,
 	DRM_FORMAT_BGR565,
 	DRM_FORMAT_BGR888,
 	DRM_FORMAT_BGRA5551,
 	DRM_FORMAT_BGRA4444,
 	DRM_FORMAT_BGRX8888,
 	DRM_FORMAT_RGB565,
 	DRM_FORMAT_RGB888,
 	DRM_FORMAT_RGBA4444,
 	DRM_FORMAT_RGBA5551,
 	DRM_FORMAT_RGBX8888,
 	DRM_FORMAT_XBGR8888,
 	DRM_FORMAT_XRGB8888,

 	DRM_FORMAT_NV16,
 	DRM_FORMAT_NV12,
 	DRM_FORMAT_NV21,
 	DRM_FORMAT_NV61,
 	DRM_FORMAT_UYVY,
 	DRM_FORMAT_VYUY,
 	DRM_FORMAT_YUYV,
 	DRM_FORMAT_YVYU,
 	DRM_FORMAT_YUV411,
 	DRM_FORMAT_YUV420,
 	DRM_FORMAT_YUV422,
 	DRM_FORMAT_YUV444,
 	DRM_FORMAT_YVU411,
 	DRM_FORMAT_YVU420,
 	DRM_FORMAT_YVU422,
 	DRM_FORMAT_YVU444,
 };

 struct sun8i_vi_layer *sun8i_vi_layer_init_one(struct drm_device *drm,
 					       struct sun8i_mixer *mixer,
 					       int index)
 {
 	struct sun8i_vi_layer *layer;
 	int ret;

 	layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL);
 	if (!layer)
 		return ERR_PTR(-ENOMEM);

 	/* possible crtcs are set later */
 	ret = drm_universal_plane_init(drm, &layer->plane, 0,
 				       &sun8i_vi_layer_funcs,
 				       sun8i_vi_layer_formats,
 				       ARRAY_SIZE(sun8i_vi_layer_formats),
 				       NULL, DRM_PLANE_TYPE_OVERLAY, NULL);
 	if (ret) {
 		dev_err(drm->dev, "Couldn't initialize layer\n");
 		return ERR_PTR(ret);
 	}

 	/* fixed zpos for now */
 	ret = drm_plane_create_zpos_immutable_property(&layer->plane, index);
 	if (ret) {
 		dev_err(drm->dev, "Couldn't add zpos property\n");
 		return ERR_PTR(ret);
 	}

 	drm_plane_helper_add(&layer->plane, &sun8i_vi_layer_helper_funcs);
 	layer->mixer = mixer;
 	layer->channel = index;
 	layer->overlay = 0;

 	return layer;
 }
	/*
	* Copyright (C) Jernej Skrabec <jernej.skrabec@siol.net>
	*
	* 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.
	*/

	#include <drm/drm_atomic.h>
	#include <drm/drm_atomic_helper.h>
	#include <drm/drm_crtc.h>
	#include <drm/drm_crtc_helper.h>
	#include <drm/drm_fb_cma_helper.h>
	#include <drm/drm_gem_cma_helper.h>
	#include <drm/drm_plane_helper.h>
	#include <drm/drmP.h>

	#include "sun8i_vi_layer.h"
	#include "sun8i_mixer.h"
	#include "sun8i_vi_scaler.h"

	static void sun8i_vi_layer_enable(struct sun8i_mixer *mixer, int channel,
	int overlay, bool enable)
	{
	u32 val;

	DRM_DEBUG_DRIVER("%sabling VI channel %d overlay %d\n",
	enable ? "En" : "Dis", channel, overlay);

	if (enable)
	val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN;
	else
	val = 0;

	regmap_update_bits(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR_EN, val);

	if (enable)
	val = SUN8I_MIXER_BLEND_PIPE_CTL_EN(channel);
	else
	val = 0;

	regmap_update_bits(mixer->engine.regs,
	SUN8I_MIXER_BLEND_PIPE_CTL,
	SUN8I_MIXER_BLEND_PIPE_CTL_EN(channel), val);
	}

	static int sun8i_vi_layer_update_coord(struct sun8i_mixer *mixer, int channel,
	int overlay, struct drm_plane *plane)
	{
	struct drm_plane_state *state = plane->state;
	const struct drm_format_info *format = state->fb->format;
	u32 src_w, src_h, dst_w, dst_h;
	u32 outsize, insize;
	u32 hphase, vphase;
	bool subsampled;

	DRM_DEBUG_DRIVER("Updating VI channel %d overlay %d\n",
	channel, overlay);

	src_w = drm_rect_width(&state->src) >> 16;
	src_h = drm_rect_height(&state->src) >> 16;
	dst_w = drm_rect_width(&state->dst);
	dst_h = drm_rect_height(&state->dst);

	hphase = state->src.x1 & 0xffff;
	vphase = state->src.y1 & 0xffff;

	/* make coordinates dividable by subsampling factor */
	if (format->hsub > 1) {
	int mask, remainder;

	mask = format->hsub - 1;
	remainder = (state->src.x1 >> 16) & mask;
	src_w = (src_w + remainder) & ~mask;
	hphase += remainder << 16;
	}

	if (format->vsub > 1) {
	int mask, remainder;

	mask = format->vsub - 1;
	remainder = (state->src.y1 >> 16) & mask;
	src_h = (src_h + remainder) & ~mask;
	vphase += remainder << 16;
	}

	insize = SUN8I_MIXER_SIZE(src_w, src_h);
	outsize = SUN8I_MIXER_SIZE(dst_w, dst_h);

	/* Set height and width */
	DRM_DEBUG_DRIVER("Layer source offset X: %d Y: %d\n",
	(state->src.x1 >> 16) & ~(format->hsub - 1),
	(state->src.y1 >> 16) & ~(format->vsub - 1));
	DRM_DEBUG_DRIVER("Layer source size W: %d H: %d\n", src_w, src_h);
	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_SIZE(channel, overlay),
	insize);
	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_OVL_SIZE(channel),
	insize);

	/*
	* Scaler must be enabled for subsampled formats, so it scales
	* chroma to same size as luma.
	*/
	subsampled = format->hsub > 1 \|\| format->vsub > 1;

	if (insize != outsize \|\| subsampled \|\| hphase \|\| vphase) {
	u32 hscale, vscale;

	DRM_DEBUG_DRIVER("HW scaling is enabled\n");

	hscale = state->src_w / state->crtc_w;
	vscale = state->src_h / state->crtc_h;

	sun8i_vi_scaler_setup(mixer, channel, src_w, src_h, dst_w,
	dst_h, hscale, vscale, hphase, vphase,
	format);
	sun8i_vi_scaler_enable(mixer, channel, true);
	} else {
	DRM_DEBUG_DRIVER("HW scaling is not needed\n");
	sun8i_vi_scaler_enable(mixer, channel, false);
	}

	/* Set base coordinates */
	DRM_DEBUG_DRIVER("Layer destination coordinates X: %d Y: %d\n",
	state->dst.x1, state->dst.y1);
	DRM_DEBUG_DRIVER("Layer destination size W: %d H: %d\n", dst_w, dst_h);
	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_BLEND_ATTR_COORD(channel),
	SUN8I_MIXER_COORD(state->dst.x1, state->dst.y1));
	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_BLEND_ATTR_INSIZE(channel),
	outsize);

	return 0;
	}

	static int sun8i_vi_layer_update_formats(struct sun8i_mixer *mixer, int channel,
	int overlay, struct drm_plane *plane)
	{
	struct drm_plane_state *state = plane->state;
	const struct de2_fmt_info *fmt_info;
	u32 val;

	fmt_info = sun8i_mixer_format_info(state->fb->format->format);
	if (!fmt_info) {
	DRM_DEBUG_DRIVER("Invalid format\n");
	return -EINVAL;
	}

	val = fmt_info->de2_fmt << SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_OFFSET;
	regmap_update_bits(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR_FBFMT_MASK, val);

	if (fmt_info->csc != SUN8I_CSC_MODE_OFF) {
	sun8i_csc_set_ccsc_coefficients(mixer, channel, fmt_info->csc);
	sun8i_csc_enable_ccsc(mixer, channel, true);
	} else {
	sun8i_csc_enable_ccsc(mixer, channel, false);
	}

	if (fmt_info->rgb)
	val = SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE;
	else
	val = 0;

	regmap_update_bits(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR(channel, overlay),
	SUN8I_MIXER_CHAN_VI_LAYER_ATTR_RGB_MODE, val);

	return 0;
	}

	static int sun8i_vi_layer_update_buffer(struct sun8i_mixer *mixer, int channel,
	int overlay, struct drm_plane *plane)
	{
	struct drm_plane_state *state = plane->state;
	struct drm_framebuffer *fb = state->fb;
	const struct drm_format_info *format = fb->format;
	struct drm_gem_cma_object *gem;
	u32 dx, dy, src_x, src_y;
	dma_addr_t paddr;
	int i;

	/* Adjust x and y to be dividable by subsampling factor */
	src_x = (state->src.x1 >> 16) & ~(format->hsub - 1);
	src_y = (state->src.y1 >> 16) & ~(format->vsub - 1);

	for (i = 0; i < format->num_planes; i++) {
	/* Get the physical address of the buffer in memory */
	gem = drm_fb_cma_get_gem_obj(fb, i);

	DRM_DEBUG_DRIVER("Using GEM @ %pad\n", &gem->paddr);

	/* Compute the start of the displayed memory */
	paddr = gem->paddr + fb->offsets[i];

	dx = src_x;
	dy = src_y;

	if (i > 0) {
	dx /= format->hsub;
	dy /= format->vsub;
	}

	/* Fixup framebuffer address for src coordinates */
	paddr += dx * format->cpp[i];
	paddr += dy * fb->pitches[i];

	/* Set the line width */
	DRM_DEBUG_DRIVER("Layer %d. line width: %d bytes\n",
	i + 1, fb->pitches[i]);
	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_PITCH(channel,
	overlay, i),
	fb->pitches[i]);

	DRM_DEBUG_DRIVER("Setting %d. buffer address to %pad\n",
	i + 1, &paddr);

	regmap_write(mixer->engine.regs,
	SUN8I_MIXER_CHAN_VI_LAYER_TOP_LADDR(channel,
	overlay, i),
	lower_32_bits(paddr));
	}

	return 0;
	}

	static int sun8i_vi_layer_atomic_check(struct drm_plane *plane,
	struct drm_plane_state *state)
	{
	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
	struct drm_crtc *crtc = state->crtc;
	struct drm_crtc_state *crtc_state;
	int min_scale, max_scale;

	if (!crtc)
	return 0;

	crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc);
	if (WARN_ON(!crtc_state))
	return -EINVAL;

	min_scale = DRM_PLANE_HELPER_NO_SCALING;
	max_scale = DRM_PLANE_HELPER_NO_SCALING;

	if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
	min_scale = SUN8I_VI_SCALER_SCALE_MIN;
	max_scale = SUN8I_VI_SCALER_SCALE_MAX;
	}

	return drm_atomic_helper_check_plane_state(state, crtc_state,
	min_scale, max_scale,
	true, true);
	}

	static void sun8i_vi_layer_atomic_disable(struct drm_plane *plane,
	struct drm_plane_state *old_state)
	{
	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
	struct sun8i_mixer *mixer = layer->mixer;

	sun8i_vi_layer_enable(mixer, layer->channel, layer->overlay, false);
	}

	static void sun8i_vi_layer_atomic_update(struct drm_plane *plane,
	struct drm_plane_state *old_state)
	{
	struct sun8i_vi_layer *layer = plane_to_sun8i_vi_layer(plane);
	struct sun8i_mixer *mixer = layer->mixer;

	if (!plane->state->visible) {
	sun8i_vi_layer_enable(mixer, layer->channel,
	layer->overlay, false);
	return;
	}

	sun8i_vi_layer_update_coord(mixer, layer->channel,
	layer->overlay, plane);
	sun8i_vi_layer_update_formats(mixer, layer->channel,
	layer->overlay, plane);
	sun8i_vi_layer_update_buffer(mixer, layer->channel,
	layer->overlay, plane);
	sun8i_vi_layer_enable(mixer, layer->channel, layer->overlay, true);
	}

	static struct drm_plane_helper_funcs sun8i_vi_layer_helper_funcs = {
	.atomic_check = sun8i_vi_layer_atomic_check,
	.atomic_disable = sun8i_vi_layer_atomic_disable,
	.atomic_update = sun8i_vi_layer_atomic_update,
	};

	static const struct drm_plane_funcs sun8i_vi_layer_funcs = {
	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
	.destroy = drm_plane_cleanup,
	.disable_plane = drm_atomic_helper_disable_plane,
	.reset = drm_atomic_helper_plane_reset,
	.update_plane = drm_atomic_helper_update_plane,
	};

	/*
	* While all RGB formats are supported, VI planes don't support
	* alpha blending, so there is no point having formats with alpha
	* channel if their opaque analog exist.
	*/
	static const u32 sun8i_vi_layer_formats[] = {
	DRM_FORMAT_ABGR1555,
	DRM_FORMAT_ABGR4444,
	DRM_FORMAT_ARGB1555,
	DRM_FORMAT_ARGB4444,
	DRM_FORMAT_BGR565,
	DRM_FORMAT_BGR888,
	DRM_FORMAT_BGRA5551,
	DRM_FORMAT_BGRA4444,
	DRM_FORMAT_BGRX8888,
	DRM_FORMAT_RGB565,
	DRM_FORMAT_RGB888,
	DRM_FORMAT_RGBA4444,
	DRM_FORMAT_RGBA5551,
	DRM_FORMAT_RGBX8888,
	DRM_FORMAT_XBGR8888,
	DRM_FORMAT_XRGB8888,

	DRM_FORMAT_NV16,
	DRM_FORMAT_NV12,
	DRM_FORMAT_NV21,
	DRM_FORMAT_NV61,
	DRM_FORMAT_UYVY,
	DRM_FORMAT_VYUY,
	DRM_FORMAT_YUYV,
	DRM_FORMAT_YVYU,
	DRM_FORMAT_YUV411,
	DRM_FORMAT_YUV420,
	DRM_FORMAT_YUV422,
	DRM_FORMAT_YUV444,
	DRM_FORMAT_YVU411,
	DRM_FORMAT_YVU420,
	DRM_FORMAT_YVU422,
	DRM_FORMAT_YVU444,
	};

	struct sun8i_vi_layer sun8i_vi_layer_init_one(struct drm_device drm,
	struct sun8i_mixer *mixer,
	int index)
	{
	struct sun8i_vi_layer *layer;
	int ret;

	layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL);
	if (!layer)
	return ERR_PTR(-ENOMEM);

	/* possible crtcs are set later */
	ret = drm_universal_plane_init(drm, &layer->plane, 0,
	&sun8i_vi_layer_funcs,
	sun8i_vi_layer_formats,
	ARRAY_SIZE(sun8i_vi_layer_formats),
	NULL, DRM_PLANE_TYPE_OVERLAY, NULL);
	if (ret) {
	dev_err(drm->dev, "Couldn't initialize layer\n");
	return ERR_PTR(ret);
	}

	/* fixed zpos for now */
	ret = drm_plane_create_zpos_immutable_property(&layer->plane, index);
	if (ret) {
	dev_err(drm->dev, "Couldn't add zpos property\n");
	return ERR_PTR(ret);
	}

	drm_plane_helper_add(&layer->plane, &sun8i_vi_layer_helper_funcs);
	layer->mixer = mixer;
	layer->channel = index;
	layer->overlay = 0;

	return layer;
	}