1/*
  2 * Copyright (C) 2015 Free Electrons
  3 * Copyright (C) 2015 NextThing Co
  4 *
  5 * Maxime Ripard <maxime.ripard@free-electrons.com>
  6 *
  7 * This program is free software; you can redistribute it and/or
  8 * modify it under the terms of the GNU General Public License as
  9 * published by the Free Software Foundation; either version 2 of
 10 * the License, or (at your option) any later version.
 11 */
 12
 13#include <drm/drm_atomic_helper.h>
 14#include <drm/drm_crtc.h>
 15#include <drm/drm_plane_helper.h>
 16#include <drm/drmP.h>
 17
 18#include "sun4i_backend.h"
 19#include "sun4i_drv.h"
 20#include "sun4i_layer.h"
 21
 22struct sun4i_plane_desc {
 23	       enum drm_plane_type     type;
 24	       u8                      pipe;
 25	       const uint32_t          *formats;
 26	       uint32_t                nformats;
 27};
 28
 29static int sun4i_backend_layer_atomic_check(struct drm_plane *plane,
 30					    struct drm_plane_state *state)
 31{
 32	return 0;
 33}
 34
 35static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane,
 36					       struct drm_plane_state *old_state)
 37{
 38	struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
 39	struct sun4i_drv *drv = layer->drv;
 40	struct sun4i_backend *backend = drv->backend;
 41
 42	sun4i_backend_layer_enable(backend, layer->id, false);
 43}
 44
 45static void sun4i_backend_layer_atomic_update(struct drm_plane *plane,
 46					      struct drm_plane_state *old_state)
 47{
 48	struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
 49	struct sun4i_drv *drv = layer->drv;
 50	struct sun4i_backend *backend = drv->backend;
 51
 52	sun4i_backend_update_layer_coord(backend, layer->id, plane);
 53	sun4i_backend_update_layer_formats(backend, layer->id, plane);
 54	sun4i_backend_update_layer_buffer(backend, layer->id, plane);
 55	sun4i_backend_layer_enable(backend, layer->id, true);
 56}
 57
 58static struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = {
 59	.atomic_check	= sun4i_backend_layer_atomic_check,
 60	.atomic_disable	= sun4i_backend_layer_atomic_disable,
 61	.atomic_update	= sun4i_backend_layer_atomic_update,
 62};
 63
 64static const struct drm_plane_funcs sun4i_backend_layer_funcs = {
 65	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
 66	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
 67	.destroy		= drm_plane_cleanup,
 68	.disable_plane		= drm_atomic_helper_disable_plane,
 69	.reset			= drm_atomic_helper_plane_reset,
 70	.update_plane		= drm_atomic_helper_update_plane,
 71};
 72
 73static const uint32_t sun4i_backend_layer_formats_primary[] = {
 74	DRM_FORMAT_ARGB8888,
 75	DRM_FORMAT_RGB888,
 76	DRM_FORMAT_RGB565,
 77	DRM_FORMAT_XRGB8888,
 78};
 79
 80static const uint32_t sun4i_backend_layer_formats_overlay[] = {
 81	DRM_FORMAT_ARGB8888,
 82	DRM_FORMAT_ARGB4444,
 83	DRM_FORMAT_ARGB1555,
 84	DRM_FORMAT_RGBA5551,
 85	DRM_FORMAT_RGBA4444,
 86	DRM_FORMAT_RGB888,
 87	DRM_FORMAT_RGB565,
 88	DRM_FORMAT_XRGB8888,
 89};
 90
 91static const struct sun4i_plane_desc sun4i_backend_planes[] = {
 92	{
 93		.type = DRM_PLANE_TYPE_PRIMARY,
 94		.pipe = 0,
 95		.formats = sun4i_backend_layer_formats_primary,
 96		.nformats = ARRAY_SIZE(sun4i_backend_layer_formats_primary),
 97	},
 98	{
 99		.type = DRM_PLANE_TYPE_OVERLAY,
100		.pipe = 1,
101		.formats = sun4i_backend_layer_formats_overlay,
102		.nformats = ARRAY_SIZE(sun4i_backend_layer_formats_overlay),
103	},
104};
105
106static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm,
107						const struct sun4i_plane_desc *plane)
108{
109	struct sun4i_drv *drv = drm->dev_private;
110	struct sun4i_layer *layer;
111	int ret;
112
113	layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL);
114	if (!layer)
115		return ERR_PTR(-ENOMEM);
116
117	ret = drm_universal_plane_init(drm, &layer->plane, BIT(0),
118				       &sun4i_backend_layer_funcs,
119				       plane->formats, plane->nformats,
120				       plane->type, NULL);
121	if (ret) {
122		dev_err(drm->dev, "Couldn't initialize layer\n");
123		return ERR_PTR(ret);
124	}
125
126	drm_plane_helper_add(&layer->plane,
127			     &sun4i_backend_layer_helper_funcs);
128	layer->drv = drv;
129
130	if (plane->type == DRM_PLANE_TYPE_PRIMARY)
131		drv->primary = &layer->plane;
132
133	return layer;
134}
135
136struct sun4i_layer **sun4i_layers_init(struct drm_device *drm)
137{
138	struct sun4i_drv *drv = drm->dev_private;
139	struct sun4i_layer **layers;
140	int i;
141
142	layers = devm_kcalloc(drm->dev, ARRAY_SIZE(sun4i_backend_planes),
143			      sizeof(**layers), GFP_KERNEL);
144	if (!layers)
145		return ERR_PTR(-ENOMEM);
146
147	/*
148	 * The hardware is a bit unusual here.
149	 *
150	 * Even though it supports 4 layers, it does the composition
151	 * in two separate steps.
152	 *
153	 * The first one is assigning a layer to one of its two
154	 * pipes. If more that 1 layer is assigned to the same pipe,
155	 * and if pixels overlaps, the pipe will take the pixel from
156	 * the layer with the highest priority.
157	 *
158	 * The second step is the actual alpha blending, that takes
159	 * the two pipes as input, and uses the eventual alpha
160	 * component to do the transparency between the two.
161	 *
162	 * This two steps scenario makes us unable to guarantee a
163	 * robust alpha blending between the 4 layers in all
164	 * situations. So we just expose two layers, one per pipe. On
165	 * SoCs that support it, sprites could fill the need for more
166	 * layers.
167	 */
168	for (i = 0; i < ARRAY_SIZE(sun4i_backend_planes); i++) {
169		const struct sun4i_plane_desc *plane = &sun4i_backend_planes[i];
170		struct sun4i_layer *layer = layers[i];
171
172		layer = sun4i_layer_init_one(drm, plane);
173		if (IS_ERR(layer)) {
174			dev_err(drm->dev, "Couldn't initialize %s plane\n",
175				i ? "overlay" : "primary");
176			return ERR_CAST(layer);
177		};
178
179		DRM_DEBUG_DRIVER("Assigning %s plane to pipe %d\n",
180				 i ? "overlay" : "primary", plane->pipe);
181		regmap_update_bits(drv->backend->regs, SUN4I_BACKEND_ATTCTL_REG0(i),
182				   SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL_MASK,
183				   SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL(plane->pipe));
184
185		layer->id = i;
186	};
187
188	return layers;
189}