2 * Copyright (C) 2015 Free Electrons
3 * Copyright (C) 2015 NextThing Co
5 * Maxime Ripard <maxime.ripard@free-electrons.com>
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.
13 #include <drm/drm_atomic_helper.h>
14 #include <drm/drm_crtc.h>
15 #include <drm/drm_plane_helper.h>
18 #include "sun4i_backend.h"
19 #include "sun4i_layer.h"
21 struct sun4i_plane_desc {
22 enum drm_plane_type type;
24 const uint32_t *formats;
28 static int sun4i_backend_layer_atomic_check(struct drm_plane *plane,
29 struct drm_plane_state *state)
34 static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane,
35 struct drm_plane_state *old_state)
37 struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
38 struct sun4i_backend *backend = layer->backend;
40 sun4i_backend_layer_enable(backend, layer->id, false);
43 static void sun4i_backend_layer_atomic_update(struct drm_plane *plane,
44 struct drm_plane_state *old_state)
46 struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
47 struct sun4i_backend *backend = layer->backend;
49 sun4i_backend_update_layer_coord(backend, layer->id, plane);
50 sun4i_backend_update_layer_formats(backend, layer->id, plane);
51 sun4i_backend_update_layer_buffer(backend, layer->id, plane);
52 sun4i_backend_layer_enable(backend, layer->id, true);
55 static struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = {
56 .atomic_check = sun4i_backend_layer_atomic_check,
57 .atomic_disable = sun4i_backend_layer_atomic_disable,
58 .atomic_update = sun4i_backend_layer_atomic_update,
61 static const struct drm_plane_funcs sun4i_backend_layer_funcs = {
62 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
63 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
64 .destroy = drm_plane_cleanup,
65 .disable_plane = drm_atomic_helper_disable_plane,
66 .reset = drm_atomic_helper_plane_reset,
67 .update_plane = drm_atomic_helper_update_plane,
70 static const uint32_t sun4i_backend_layer_formats_primary[] = {
77 static const uint32_t sun4i_backend_layer_formats_overlay[] = {
88 static const struct sun4i_plane_desc sun4i_backend_planes[] = {
90 .type = DRM_PLANE_TYPE_PRIMARY,
92 .formats = sun4i_backend_layer_formats_primary,
93 .nformats = ARRAY_SIZE(sun4i_backend_layer_formats_primary),
96 .type = DRM_PLANE_TYPE_OVERLAY,
98 .formats = sun4i_backend_layer_formats_overlay,
99 .nformats = ARRAY_SIZE(sun4i_backend_layer_formats_overlay),
103 static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm,
104 struct sun4i_backend *backend,
105 const struct sun4i_plane_desc *plane)
107 struct sun4i_layer *layer;
110 layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL);
112 return ERR_PTR(-ENOMEM);
114 /* possible crtcs are set later */
115 ret = drm_universal_plane_init(drm, &layer->plane, 0,
116 &sun4i_backend_layer_funcs,
117 plane->formats, plane->nformats,
120 dev_err(drm->dev, "Couldn't initialize layer\n");
124 drm_plane_helper_add(&layer->plane,
125 &sun4i_backend_layer_helper_funcs);
126 layer->backend = backend;
131 struct sun4i_layer **sun4i_layers_init(struct drm_device *drm,
132 struct sun4i_backend *backend)
134 struct sun4i_layer **layers;
137 layers = devm_kcalloc(drm->dev, ARRAY_SIZE(sun4i_backend_planes) + 1,
138 sizeof(*layers), GFP_KERNEL);
140 return ERR_PTR(-ENOMEM);
143 * The hardware is a bit unusual here.
145 * Even though it supports 4 layers, it does the composition
146 * in two separate steps.
148 * The first one is assigning a layer to one of its two
149 * pipes. If more that 1 layer is assigned to the same pipe,
150 * and if pixels overlaps, the pipe will take the pixel from
151 * the layer with the highest priority.
153 * The second step is the actual alpha blending, that takes
154 * the two pipes as input, and uses the eventual alpha
155 * component to do the transparency between the two.
157 * This two steps scenario makes us unable to guarantee a
158 * robust alpha blending between the 4 layers in all
159 * situations. So we just expose two layers, one per pipe. On
160 * SoCs that support it, sprites could fill the need for more
163 for (i = 0; i < ARRAY_SIZE(sun4i_backend_planes); i++) {
164 const struct sun4i_plane_desc *plane = &sun4i_backend_planes[i];
165 struct sun4i_layer *layer;
167 layer = sun4i_layer_init_one(drm, backend, plane);
169 dev_err(drm->dev, "Couldn't initialize %s plane\n",
170 i ? "overlay" : "primary");
171 return ERR_CAST(layer);
174 DRM_DEBUG_DRIVER("Assigning %s plane to pipe %d\n",
175 i ? "overlay" : "primary", plane->pipe);
176 regmap_update_bits(backend->regs, SUN4I_BACKEND_ATTCTL_REG0(i),
177 SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL_MASK,
178 SUN4I_BACKEND_ATTCTL_REG0_LAY_PIPESEL(plane->pipe));