[deliverable/linux.git] / drivers / gpu / drm / rcar-du / rcar_du_vsp.c

/*
 * rcar_du_vsp.h  --  R-Car Display Unit VSP-Based Compositor
 *
 * Copyright (C) 2015 Renesas Electronics Corporation
 *
 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
 *
 * 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/drmP.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 <linux/of_platform.h>
#include <linux/videodev2.h>

#include <media/vsp1.h>

#include "rcar_du_drv.h"
#include "rcar_du_kms.h"
#include "rcar_du_vsp.h"

void rcar_du_vsp_enable(struct rcar_du_crtc *crtc)
{
	const struct drm_display_mode *mode = &crtc->crtc.state->adjusted_mode;
	struct rcar_du_device *rcdu = crtc->group->dev;
	struct rcar_du_plane_state state = {
		.state = {
			.crtc = &crtc->crtc,
			.crtc_x = 0,
			.crtc_y = 0,
			.crtc_w = mode->hdisplay,
			.crtc_h = mode->vdisplay,
			.src_x = 0,
			.src_y = 0,
			.src_w = mode->hdisplay << 16,
			.src_h = mode->vdisplay << 16,
			.zpos = 0,
		},
		.format = rcar_du_format_info(DRM_FORMAT_ARGB8888),
		.source = RCAR_DU_PLANE_VSPD1,
		.alpha = 255,
		.colorkey = 0,
	};

	if (rcdu->info->gen >= 3)
		state.hwindex = (crtc->index % 2) ? 2 : 0;
	else
		state.hwindex = crtc->index % 2;

	__rcar_du_plane_setup(crtc->group, &state);

	/* Ensure that the plane source configuration takes effect by requesting
	 * a restart of the group. See rcar_du_plane_atomic_update() for a more
	 * detailed explanation.
	 *
	 * TODO: Check whether this is still needed on Gen3.
	 */
	crtc->group->need_restart = true;

	vsp1_du_setup_lif(crtc->vsp->vsp, mode->hdisplay, mode->vdisplay);
}

void rcar_du_vsp_disable(struct rcar_du_crtc *crtc)
{
	vsp1_du_setup_lif(crtc->vsp->vsp, 0, 0);
}

void rcar_du_vsp_atomic_begin(struct rcar_du_crtc *crtc)
{
	vsp1_du_atomic_begin(crtc->vsp->vsp);
}

void rcar_du_vsp_atomic_flush(struct rcar_du_crtc *crtc)
{
	vsp1_du_atomic_flush(crtc->vsp->vsp);
}

/* Keep the two tables in sync. */
static const u32 formats_kms[] = {
	DRM_FORMAT_RGB332,
	DRM_FORMAT_ARGB4444,
	DRM_FORMAT_XRGB4444,
	DRM_FORMAT_ARGB1555,
	DRM_FORMAT_XRGB1555,
	DRM_FORMAT_RGB565,
	DRM_FORMAT_BGR888,
	DRM_FORMAT_RGB888,
	DRM_FORMAT_BGRA8888,
	DRM_FORMAT_BGRX8888,
	DRM_FORMAT_ARGB8888,
	DRM_FORMAT_XRGB8888,
	DRM_FORMAT_UYVY,
	DRM_FORMAT_VYUY,
	DRM_FORMAT_YUYV,
	DRM_FORMAT_YVYU,
	DRM_FORMAT_NV12,
	DRM_FORMAT_NV21,
	DRM_FORMAT_NV16,
	DRM_FORMAT_NV61,
	DRM_FORMAT_YUV420,
	DRM_FORMAT_YVU420,
	DRM_FORMAT_YUV422,
	DRM_FORMAT_YVU422,
	DRM_FORMAT_YUV444,
	DRM_FORMAT_YVU444,
};

static const u32 formats_v4l2[] = {
	V4L2_PIX_FMT_RGB332,
	V4L2_PIX_FMT_ARGB444,
	V4L2_PIX_FMT_XRGB444,
	V4L2_PIX_FMT_ARGB555,
	V4L2_PIX_FMT_XRGB555,
	V4L2_PIX_FMT_RGB565,
	V4L2_PIX_FMT_RGB24,
	V4L2_PIX_FMT_BGR24,
	V4L2_PIX_FMT_ARGB32,
	V4L2_PIX_FMT_XRGB32,
	V4L2_PIX_FMT_ABGR32,
	V4L2_PIX_FMT_XBGR32,
	V4L2_PIX_FMT_UYVY,
	V4L2_PIX_FMT_VYUY,
	V4L2_PIX_FMT_YUYV,
	V4L2_PIX_FMT_YVYU,
	V4L2_PIX_FMT_NV12M,
	V4L2_PIX_FMT_NV21M,
	V4L2_PIX_FMT_NV16M,
	V4L2_PIX_FMT_NV61M,
	V4L2_PIX_FMT_YUV420M,
	V4L2_PIX_FMT_YVU420M,
	V4L2_PIX_FMT_YUV422M,
	V4L2_PIX_FMT_YVU422M,
	V4L2_PIX_FMT_YUV444M,
	V4L2_PIX_FMT_YVU444M,
};

static void rcar_du_vsp_plane_setup(struct rcar_du_vsp_plane *plane)
{
	struct rcar_du_vsp_plane_state *state =
		to_rcar_vsp_plane_state(plane->plane.state);
	struct drm_framebuffer *fb = plane->plane.state->fb;
	struct vsp1_du_atomic_config cfg = {
		.pixelformat = 0,
		.pitch = fb->pitches[0],
		.alpha = state->alpha,
		.zpos = state->state.zpos,
	};
	unsigned int i;

	cfg.src.left = state->state.src_x >> 16;
	cfg.src.top = state->state.src_y >> 16;
	cfg.src.width = state->state.src_w >> 16;
	cfg.src.height = state->state.src_h >> 16;

	cfg.dst.left = state->state.crtc_x;
	cfg.dst.top = state->state.crtc_y;
	cfg.dst.width = state->state.crtc_w;
	cfg.dst.height = state->state.crtc_h;

	for (i = 0; i < state->format->planes; ++i) {
		struct drm_gem_cma_object *gem;

		gem = drm_fb_cma_get_gem_obj(fb, i);
		cfg.mem[i] = gem->paddr + fb->offsets[i];
	}

	for (i = 0; i < ARRAY_SIZE(formats_kms); ++i) {
		if (formats_kms[i] == state->format->fourcc) {
			cfg.pixelformat = formats_v4l2[i];
			break;
		}
	}

	vsp1_du_atomic_update(plane->vsp->vsp, plane->index, &cfg);
}

static int rcar_du_vsp_plane_atomic_check(struct drm_plane *plane,
					  struct drm_plane_state *state)
{
	struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
	struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);
	struct rcar_du_device *rcdu = rplane->vsp->dev;

	if (!state->fb || !state->crtc) {
		rstate->format = NULL;
		return 0;
	}

	if (state->src_w >> 16 != state->crtc_w ||
	    state->src_h >> 16 != state->crtc_h) {
		dev_dbg(rcdu->dev, "%s: scaling not supported\n", __func__);
		return -EINVAL;
	}

	rstate->format = rcar_du_format_info(state->fb->pixel_format);
	if (rstate->format == NULL) {
		dev_dbg(rcdu->dev, "%s: unsupported format %08x\n", __func__,
			state->fb->pixel_format);
		return -EINVAL;
	}

	return 0;
}

static void rcar_du_vsp_plane_atomic_update(struct drm_plane *plane,
					struct drm_plane_state *old_state)
{
	struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);

	if (plane->state->crtc)
		rcar_du_vsp_plane_setup(rplane);
	else
		vsp1_du_atomic_update(rplane->vsp->vsp, rplane->index, NULL);
}

static const struct drm_plane_helper_funcs rcar_du_vsp_plane_helper_funcs = {
	.atomic_check = rcar_du_vsp_plane_atomic_check,
	.atomic_update = rcar_du_vsp_plane_atomic_update,
};

static struct drm_plane_state *
rcar_du_vsp_plane_atomic_duplicate_state(struct drm_plane *plane)
{
	struct rcar_du_vsp_plane_state *state;
	struct rcar_du_vsp_plane_state *copy;

	if (WARN_ON(!plane->state))
		return NULL;

	state = to_rcar_vsp_plane_state(plane->state);
	copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
	if (copy == NULL)
		return NULL;

	__drm_atomic_helper_plane_duplicate_state(plane, &copy->state);

	return &copy->state;
}

static void rcar_du_vsp_plane_atomic_destroy_state(struct drm_plane *plane,
						   struct drm_plane_state *state)
{
	__drm_atomic_helper_plane_destroy_state(state);
	kfree(to_rcar_vsp_plane_state(state));
}

static void rcar_du_vsp_plane_reset(struct drm_plane *plane)
{
	struct rcar_du_vsp_plane_state *state;

	if (plane->state) {
		rcar_du_vsp_plane_atomic_destroy_state(plane, plane->state);
		plane->state = NULL;
	}

	state = kzalloc(sizeof(*state), GFP_KERNEL);
	if (state == NULL)
		return;

	state->alpha = 255;
	state->state.zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : 1;

	plane->state = &state->state;
	plane->state->plane = plane;
}

static int rcar_du_vsp_plane_atomic_set_property(struct drm_plane *plane,
	struct drm_plane_state *state, struct drm_property *property,
	uint64_t val)
{
	struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
	struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;

	if (property == rcdu->props.alpha)
		rstate->alpha = val;
	else
		return -EINVAL;

	return 0;
}

static int rcar_du_vsp_plane_atomic_get_property(struct drm_plane *plane,
	const struct drm_plane_state *state, struct drm_property *property,
	uint64_t *val)
{
	const struct rcar_du_vsp_plane_state *rstate =
		container_of(state, const struct rcar_du_vsp_plane_state, state);
	struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;

	if (property == rcdu->props.alpha)
		*val = rstate->alpha;
	else
		return -EINVAL;

	return 0;
}

static const struct drm_plane_funcs rcar_du_vsp_plane_funcs = {
	.update_plane = drm_atomic_helper_update_plane,
	.disable_plane = drm_atomic_helper_disable_plane,
	.reset = rcar_du_vsp_plane_reset,
	.set_property = drm_atomic_helper_plane_set_property,
	.destroy = drm_plane_cleanup,
	.atomic_duplicate_state = rcar_du_vsp_plane_atomic_duplicate_state,
	.atomic_destroy_state = rcar_du_vsp_plane_atomic_destroy_state,
	.atomic_set_property = rcar_du_vsp_plane_atomic_set_property,
	.atomic_get_property = rcar_du_vsp_plane_atomic_get_property,
};

int rcar_du_vsp_init(struct rcar_du_vsp *vsp)
{
	struct rcar_du_device *rcdu = vsp->dev;
	struct platform_device *pdev;
	struct device_node *np;
	unsigned int i;
	int ret;

	/* Find the VSP device and initialize it. */
	np = of_parse_phandle(rcdu->dev->of_node, "vsps", vsp->index);
	if (!np) {
		dev_err(rcdu->dev, "vsps node not found\n");
		return -ENXIO;
	}

	pdev = of_find_device_by_node(np);
	of_node_put(np);
	if (!pdev)
		return -ENXIO;

	vsp->vsp = &pdev->dev;

	ret = vsp1_du_init(vsp->vsp);
	if (ret < 0)
		return ret;

	 /* The VSP2D (Gen3) has 5 RPFs, but the VSP1D (Gen2) is limited to
	  * 4 RPFs.
	  */
	vsp->num_planes = rcdu->info->gen >= 3 ? 5 : 4;

	vsp->planes = devm_kcalloc(rcdu->dev, vsp->num_planes,
				   sizeof(*vsp->planes), GFP_KERNEL);
	if (!vsp->planes)
		return -ENOMEM;

	for (i = 0; i < vsp->num_planes; ++i) {
		enum drm_plane_type type = i ? DRM_PLANE_TYPE_OVERLAY
					 : DRM_PLANE_TYPE_PRIMARY;
		struct rcar_du_vsp_plane *plane = &vsp->planes[i];

		plane->vsp = vsp;
		plane->index = i;

		ret = drm_universal_plane_init(rcdu->ddev, &plane->plane,
					       1 << vsp->index,
					       &rcar_du_vsp_plane_funcs,
					       formats_kms,
					       ARRAY_SIZE(formats_kms), type,
					       NULL);
		if (ret < 0)
			return ret;

		drm_plane_helper_add(&plane->plane,
				     &rcar_du_vsp_plane_helper_funcs);

		if (type == DRM_PLANE_TYPE_PRIMARY)
			continue;

		drm_object_attach_property(&plane->plane.base,
					   rcdu->props.alpha, 255);
		drm_plane_create_zpos_property(&plane->plane, 1, 1,
					       vsp->num_planes - 1);
	}

	return 0;
}
Commit	Line	Data
6d62ef3a LP	1	/*
	2	* rcar_du_vsp.h -- R-Car Display Unit VSP-Based Compositor
	3	*
	4	* Copyright (C) 2015 Renesas Electronics Corporation
	5	*
	6	* Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*/
	13
	14	#include <drm/drmP.h>
	15	#include <drm/drm_atomic_helper.h>
	16	#include <drm/drm_crtc.h>
	17	#include <drm/drm_crtc_helper.h>
	18	#include <drm/drm_fb_cma_helper.h>
	19	#include <drm/drm_gem_cma_helper.h>
	20	#include <drm/drm_plane_helper.h>
	21
	22	#include <linux/of_platform.h>
	23	#include <linux/videodev2.h>
	24
	25	#include <media/vsp1.h>
	26
	27	#include "rcar_du_drv.h"
	28	#include "rcar_du_kms.h"
	29	#include "rcar_du_vsp.h"
	30
	31	void rcar_du_vsp_enable(struct rcar_du_crtc *crtc)
	32	{
	33	const struct drm_display_mode *mode = &crtc->crtc.state->adjusted_mode;
2427b303	34	struct rcar_du_device *rcdu = crtc->group->dev;
6d62ef3a LP	35	struct rcar_du_plane_state state = {
	36	.state = {
	37	.crtc = &crtc->crtc,
	38	.crtc_x = 0,
	39	.crtc_y = 0,
	40	.crtc_w = mode->hdisplay,
	41	.crtc_h = mode->vdisplay,
	42	.src_x = 0,
	43	.src_y = 0,
	44	.src_w = mode->hdisplay << 16,
	45	.src_h = mode->vdisplay << 16,
2fc4d838	46	.zpos = 0,
6d62ef3a LP	47	},
6d62ef3a LP	48	.format = rcar_du_format_info(DRM_FORMAT_ARGB8888),
6d62ef3a LP	49	.source = RCAR_DU_PLANE_VSPD1,
	50	.alpha = 255,
	51	.colorkey = 0,
6d62ef3a LP	52	};
6d62ef3a LP	53
2427b303 LP	54	if (rcdu->info->gen >= 3)
	55	state.hwindex = (crtc->index % 2) ? 2 : 0;
	56	else
	57	state.hwindex = crtc->index % 2;
	58
6d62ef3a LP	59	__rcar_du_plane_setup(crtc->group, &state);
	60
	61	/* Ensure that the plane source configuration takes effect by requesting
	62	* a restart of the group. See rcar_du_plane_atomic_update() for a more
	63	* detailed explanation.
	64	*
	65	* TODO: Check whether this is still needed on Gen3.
	66	*/
	67	crtc->group->need_restart = true;
	68
	69	vsp1_du_setup_lif(crtc->vsp->vsp, mode->hdisplay, mode->vdisplay);
	70	}
	71
	72	void rcar_du_vsp_disable(struct rcar_du_crtc *crtc)
	73	{
	74	vsp1_du_setup_lif(crtc->vsp->vsp, 0, 0);
	75	}
	76
	77	void rcar_du_vsp_atomic_begin(struct rcar_du_crtc *crtc)
	78	{
	79	vsp1_du_atomic_begin(crtc->vsp->vsp);
	80	}
	81
	82	void rcar_du_vsp_atomic_flush(struct rcar_du_crtc *crtc)
	83	{
	84	vsp1_du_atomic_flush(crtc->vsp->vsp);
	85	}
	86
	87	/* Keep the two tables in sync. */
	88	static const u32 formats_kms[] = {
	89	DRM_FORMAT_RGB332,
	90	DRM_FORMAT_ARGB4444,
	91	DRM_FORMAT_XRGB4444,
	92	DRM_FORMAT_ARGB1555,
	93	DRM_FORMAT_XRGB1555,
	94	DRM_FORMAT_RGB565,
	95	DRM_FORMAT_BGR888,
	96	DRM_FORMAT_RGB888,
	97	DRM_FORMAT_BGRA8888,
	98	DRM_FORMAT_BGRX8888,
	99	DRM_FORMAT_ARGB8888,
	100	DRM_FORMAT_XRGB8888,
	101	DRM_FORMAT_UYVY,
	102	DRM_FORMAT_VYUY,
	103	DRM_FORMAT_YUYV,
	104	DRM_FORMAT_YVYU,
	105	DRM_FORMAT_NV12,
	106	DRM_FORMAT_NV21,
	107	DRM_FORMAT_NV16,
	108	DRM_FORMAT_NV61,
7863ac50 LP	109	DRM_FORMAT_YUV420,
	110	DRM_FORMAT_YVU420,
	111	DRM_FORMAT_YUV422,
	112	DRM_FORMAT_YVU422,
	113	DRM_FORMAT_YUV444,
	114	DRM_FORMAT_YVU444,
6d62ef3a LP	115	};
	116
	117	static const u32 formats_v4l2[] = {
	118	V4L2_PIX_FMT_RGB332,
	119	V4L2_PIX_FMT_ARGB444,
	120	V4L2_PIX_FMT_XRGB444,
	121	V4L2_PIX_FMT_ARGB555,
	122	V4L2_PIX_FMT_XRGB555,
	123	V4L2_PIX_FMT_RGB565,
	124	V4L2_PIX_FMT_RGB24,
	125	V4L2_PIX_FMT_BGR24,
	126	V4L2_PIX_FMT_ARGB32,
	127	V4L2_PIX_FMT_XRGB32,
	128	V4L2_PIX_FMT_ABGR32,
	129	V4L2_PIX_FMT_XBGR32,
	130	V4L2_PIX_FMT_UYVY,
	131	V4L2_PIX_FMT_VYUY,
	132	V4L2_PIX_FMT_YUYV,
	133	V4L2_PIX_FMT_YVYU,
	134	V4L2_PIX_FMT_NV12M,
	135	V4L2_PIX_FMT_NV21M,
	136	V4L2_PIX_FMT_NV16M,
	137	V4L2_PIX_FMT_NV61M,
7863ac50 LP	138	V4L2_PIX_FMT_YUV420M,
	139	V4L2_PIX_FMT_YVU420M,
	140	V4L2_PIX_FMT_YUV422M,
	141	V4L2_PIX_FMT_YVU422M,
	142	V4L2_PIX_FMT_YUV444M,
	143	V4L2_PIX_FMT_YVU444M,
6d62ef3a LP	144	};
	145
	146	static void rcar_du_vsp_plane_setup(struct rcar_du_vsp_plane *plane)
	147	{
	148	struct rcar_du_vsp_plane_state *state =
	149	to_rcar_vsp_plane_state(plane->plane.state);
	150	struct drm_framebuffer *fb = plane->plane.state->fb;
41740824 LP	151	struct vsp1_du_atomic_config cfg = {
	152	.pixelformat = 0,
	153	.pitch = fb->pitches[0],
	154	.alpha = state->alpha,
2fc4d838	155	.zpos = state->state.zpos,
41740824	156	};
6d62ef3a LP	157	unsigned int i;
6d62ef3a LP	158
41740824 LP	159	cfg.src.left = state->state.src_x >> 16;
	160	cfg.src.top = state->state.src_y >> 16;
	161	cfg.src.width = state->state.src_w >> 16;
	162	cfg.src.height = state->state.src_h >> 16;
6d62ef3a	163
41740824 LP	164	cfg.dst.left = state->state.crtc_x;
	165	cfg.dst.top = state->state.crtc_y;
	166	cfg.dst.width = state->state.crtc_w;
	167	cfg.dst.height = state->state.crtc_h;
6d62ef3a	168
7863ac50 LP	169	for (i = 0; i < state->format->planes; ++i) {
7863ac50 LP	170	struct drm_gem_cma_object *gem;
6d62ef3a	171
7863ac50	172	gem = drm_fb_cma_get_gem_obj(fb, i);
41740824	173	cfg.mem[i] = gem->paddr + fb->offsets[i];
6d62ef3a LP	174	}
	175
	176	for (i = 0; i < ARRAY_SIZE(formats_kms); ++i) {
	177	if (formats_kms[i] == state->format->fourcc) {
41740824	178	cfg.pixelformat = formats_v4l2[i];
6d62ef3a LP	179	break;
	180	}
	181	}
	182
41740824	183	vsp1_du_atomic_update(plane->vsp->vsp, plane->index, &cfg);
6d62ef3a LP	184	}
	185
	186	static int rcar_du_vsp_plane_atomic_check(struct drm_plane *plane,
	187	struct drm_plane_state *state)
	188	{
	189	struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
	190	struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);
	191	struct rcar_du_device *rcdu = rplane->vsp->dev;
	192
	193	if (!state->fb \|\| !state->crtc) {
	194	rstate->format = NULL;
	195	return 0;
	196	}
	197
	198	if (state->src_w >> 16 != state->crtc_w \|\|
	199	state->src_h >> 16 != state->crtc_h) {
	200	dev_dbg(rcdu->dev, "%s: scaling not supported\n", __func__);
	201	return -EINVAL;
	202	}
	203
	204	rstate->format = rcar_du_format_info(state->fb->pixel_format);
	205	if (rstate->format == NULL) {
	206	dev_dbg(rcdu->dev, "%s: unsupported format %08x\n", __func__,
	207	state->fb->pixel_format);
	208	return -EINVAL;
	209	}
	210
	211	return 0;
	212	}
	213
	214	static void rcar_du_vsp_plane_atomic_update(struct drm_plane *plane,
	215	struct drm_plane_state *old_state)
	216	{
	217	struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);
	218
	219	if (plane->state->crtc)
	220	rcar_du_vsp_plane_setup(rplane);
	221	else
41740824	222	vsp1_du_atomic_update(rplane->vsp->vsp, rplane->index, NULL);
6d62ef3a LP	223	}
	224
	225	static const struct drm_plane_helper_funcs rcar_du_vsp_plane_helper_funcs = {
	226	.atomic_check = rcar_du_vsp_plane_atomic_check,
	227	.atomic_update = rcar_du_vsp_plane_atomic_update,
	228	};
	229
	230	static struct drm_plane_state *
	231	rcar_du_vsp_plane_atomic_duplicate_state(struct drm_plane *plane)
	232	{
	233	struct rcar_du_vsp_plane_state *state;
	234	struct rcar_du_vsp_plane_state *copy;
	235
	236	if (WARN_ON(!plane->state))
	237	return NULL;
	238
	239	state = to_rcar_vsp_plane_state(plane->state);
	240	copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
	241	if (copy == NULL)
	242	return NULL;
	243
	244	__drm_atomic_helper_plane_duplicate_state(plane, &copy->state);
	245
	246	return &copy->state;
	247	}
	248
	249	static void rcar_du_vsp_plane_atomic_destroy_state(struct drm_plane *plane,
	250	struct drm_plane_state *state)
	251	{
2f701695	252	__drm_atomic_helper_plane_destroy_state(state);
6d62ef3a LP	253	kfree(to_rcar_vsp_plane_state(state));
	254	}
	255
	256	static void rcar_du_vsp_plane_reset(struct drm_plane *plane)
	257	{
	258	struct rcar_du_vsp_plane_state *state;
	259
	260	if (plane->state) {
	261	rcar_du_vsp_plane_atomic_destroy_state(plane, plane->state);
	262	plane->state = NULL;
	263	}
	264
	265	state = kzalloc(sizeof(*state), GFP_KERNEL);
	266	if (state == NULL)
	267	return;
	268
	269	state->alpha = 255;
2fc4d838	270	state->state.zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : 1;
6d62ef3a LP	271
	272	plane->state = &state->state;
	273	plane->state->plane = plane;
	274	}
	275
	276	static int rcar_du_vsp_plane_atomic_set_property(struct drm_plane *plane,
	277	struct drm_plane_state state, struct drm_property property,
	278	uint64_t val)
	279	{
	280	struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
	281	struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;
	282
	283	if (property == rcdu->props.alpha)
	284	rstate->alpha = val;
	285	else
	286	return -EINVAL;
	287
	288	return 0;
	289	}
	290
	291	static int rcar_du_vsp_plane_atomic_get_property(struct drm_plane *plane,
	292	const struct drm_plane_state state, struct drm_property property,
	293	uint64_t *val)
	294	{
	295	const struct rcar_du_vsp_plane_state *rstate =
	296	container_of(state, const struct rcar_du_vsp_plane_state, state);
	297	struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;
	298
	299	if (property == rcdu->props.alpha)
	300	*val = rstate->alpha;
	301	else
	302	return -EINVAL;
	303
	304	return 0;
	305	}
	306
	307	static const struct drm_plane_funcs rcar_du_vsp_plane_funcs = {
	308	.update_plane = drm_atomic_helper_update_plane,
	309	.disable_plane = drm_atomic_helper_disable_plane,
	310	.reset = rcar_du_vsp_plane_reset,
	311	.set_property = drm_atomic_helper_plane_set_property,
	312	.destroy = drm_plane_cleanup,
	313	.atomic_duplicate_state = rcar_du_vsp_plane_atomic_duplicate_state,
	314	.atomic_destroy_state = rcar_du_vsp_plane_atomic_destroy_state,
	315	.atomic_set_property = rcar_du_vsp_plane_atomic_set_property,
	316	.atomic_get_property = rcar_du_vsp_plane_atomic_get_property,
	317	};
	318
	319	int rcar_du_vsp_init(struct rcar_du_vsp *vsp)
	320	{
	321	struct rcar_du_device *rcdu = vsp->dev;
	322	struct platform_device *pdev;
	323	struct device_node *np;
	324	unsigned int i;
	325	int ret;
	326
	327	/* Find the VSP device and initialize it. */
	328	np = of_parse_phandle(rcdu->dev->of_node, "vsps", vsp->index);
	329	if (!np) {
	330	dev_err(rcdu->dev, "vsps node not found\n");
	331	return -ENXIO;
	332	}
	333
	334	pdev = of_find_device_by_node(np);
335	of_node_put(np);
336	if (!pdev)
337	return -ENXIO;
338
339	vsp->vsp = &pdev->dev;
340
341	ret = vsp1_du_init(vsp->vsp);
342	if (ret < 0)
343	return ret;
344
345	/* The VSP2D (Gen3) has 5 RPFs, but the VSP1D (Gen2) is limited to
2427b303	346	* 4 RPFs.
6d62ef3a	347	*/
2427b303	348	vsp->num_planes = rcdu->info->gen >= 3 ? 5 : 4;
6d62ef3a LP	349
	350	vsp->planes = devm_kcalloc(rcdu->dev, vsp->num_planes,
	351	sizeof(*vsp->planes), GFP_KERNEL);
	352	if (!vsp->planes)
	353	return -ENOMEM;
	354
	355	for (i = 0; i < vsp->num_planes; ++i) {
	356	enum drm_plane_type type = i ? DRM_PLANE_TYPE_OVERLAY
	357	: DRM_PLANE_TYPE_PRIMARY;
	358	struct rcar_du_vsp_plane *plane = &vsp->planes[i];
	359
	360	plane->vsp = vsp;
	361	plane->index = i;
	362
	363	ret = drm_universal_plane_init(rcdu->ddev, &plane->plane,
	364	1 << vsp->index,
	365	&rcar_du_vsp_plane_funcs,
	366	formats_kms,
	367	ARRAY_SIZE(formats_kms), type,
	368	NULL);
	369	if (ret < 0)
	370	return ret;
	371
	372	drm_plane_helper_add(&plane->plane,
	373	&rcar_du_vsp_plane_helper_funcs);
	374
	375	if (type == DRM_PLANE_TYPE_PRIMARY)
	376	continue;
	377
	378	drm_object_attach_property(&plane->plane.base,
	379	rcdu->props.alpha, 255);
2fc4d838 BG	380	drm_plane_create_zpos_property(&plane->plane, 1, 1,
2fc4d838 BG	381	vsp->num_planes - 1);
6d62ef3a LP	382	}
	383
	384	return 0;
	385	}