Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2015 Free Electrons
4 * Copyright (C) 2015 NextThing Co
5 *
6 * Maxime Ripard <maxime.ripard@free-electrons.com>
7 */
8
9#include <drm/drm_atomic.h>
10#include <drm/drm_atomic_helper.h>
11#include <drm/drm_blend.h>
12#include <drm/drm_gem_atomic_helper.h>
13
14#include "sun4i_backend.h"
15#include "sun4i_frontend.h"
16#include "sun4i_layer.h"
17#include "sunxi_engine.h"
18
19static void sun4i_backend_layer_reset(struct drm_plane *plane)
20{
21 struct sun4i_layer_state *state;
22
23 if (plane->state) {
24 state = state_to_sun4i_layer_state(plane->state);
25
26 __drm_atomic_helper_plane_destroy_state(&state->state);
27
28 kfree(state);
29 plane->state = NULL;
30 }
31
32 state = kzalloc(sizeof(*state), GFP_KERNEL);
33 if (state)
34 __drm_atomic_helper_plane_reset(plane, &state->state);
35}
36
37static struct drm_plane_state *
38sun4i_backend_layer_duplicate_state(struct drm_plane *plane)
39{
40 struct sun4i_layer_state *orig = state_to_sun4i_layer_state(plane->state);
41 struct sun4i_layer_state *copy;
42
43 copy = kzalloc(sizeof(*copy), GFP_KERNEL);
44 if (!copy)
45 return NULL;
46
47 __drm_atomic_helper_plane_duplicate_state(plane, ©->state);
48 copy->uses_frontend = orig->uses_frontend;
49
50 return ©->state;
51}
52
53static void sun4i_backend_layer_destroy_state(struct drm_plane *plane,
54 struct drm_plane_state *state)
55{
56 struct sun4i_layer_state *s_state = state_to_sun4i_layer_state(state);
57
58 __drm_atomic_helper_plane_destroy_state(state);
59
60 kfree(s_state);
61}
62
63static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane,
64 struct drm_atomic_state *state)
65{
66 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
67 plane);
68 struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(old_state);
69 struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
70 struct sun4i_backend *backend = layer->backend;
71
72 sun4i_backend_layer_enable(backend, layer->id, false);
73
74 if (layer_state->uses_frontend) {
75 unsigned long flags;
76
77 spin_lock_irqsave(&backend->frontend_lock, flags);
78 backend->frontend_teardown = true;
79 spin_unlock_irqrestore(&backend->frontend_lock, flags);
80 }
81}
82
83static void sun4i_backend_layer_atomic_update(struct drm_plane *plane,
84 struct drm_atomic_state *state)
85{
86 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
87 plane);
88 struct sun4i_layer_state *layer_state = state_to_sun4i_layer_state(new_state);
89 struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
90 struct sun4i_backend *backend = layer->backend;
91 struct sun4i_frontend *frontend = backend->frontend;
92
93 sun4i_backend_cleanup_layer(backend, layer->id);
94
95 if (layer_state->uses_frontend) {
96 sun4i_frontend_init(frontend);
97 sun4i_frontend_update_coord(frontend, plane);
98 sun4i_frontend_update_buffer(frontend, plane);
99 sun4i_frontend_update_formats(frontend, plane,
100 DRM_FORMAT_XRGB8888);
101 sun4i_backend_update_layer_frontend(backend, layer->id,
102 DRM_FORMAT_XRGB8888);
103 sun4i_frontend_enable(frontend);
104 } else {
105 sun4i_backend_update_layer_formats(backend, layer->id, plane);
106 sun4i_backend_update_layer_buffer(backend, layer->id, plane);
107 }
108
109 sun4i_backend_update_layer_coord(backend, layer->id, plane);
110 sun4i_backend_update_layer_zpos(backend, layer->id, plane);
111 sun4i_backend_layer_enable(backend, layer->id, true);
112}
113
114static bool sun4i_layer_format_mod_supported(struct drm_plane *plane,
115 uint32_t format, uint64_t modifier)
116{
117 struct sun4i_layer *layer = plane_to_sun4i_layer(plane);
118
119 if (IS_ERR_OR_NULL(layer->backend->frontend))
120 return sun4i_backend_format_is_supported(format, modifier);
121
122 return sun4i_backend_format_is_supported(format, modifier) ||
123 sun4i_frontend_format_is_supported(format, modifier);
124}
125
126static const struct drm_plane_helper_funcs sun4i_backend_layer_helper_funcs = {
127 .atomic_disable = sun4i_backend_layer_atomic_disable,
128 .atomic_update = sun4i_backend_layer_atomic_update,
129};
130
131static const struct drm_plane_funcs sun4i_backend_layer_funcs = {
132 .atomic_destroy_state = sun4i_backend_layer_destroy_state,
133 .atomic_duplicate_state = sun4i_backend_layer_duplicate_state,
134 .destroy = drm_plane_cleanup,
135 .disable_plane = drm_atomic_helper_disable_plane,
136 .reset = sun4i_backend_layer_reset,
137 .update_plane = drm_atomic_helper_update_plane,
138 .format_mod_supported = sun4i_layer_format_mod_supported,
139};
140
141static const uint32_t sun4i_layer_formats[] = {
142 DRM_FORMAT_ARGB8888,
143 DRM_FORMAT_ARGB4444,
144 DRM_FORMAT_ARGB1555,
145 DRM_FORMAT_BGRX8888,
146 DRM_FORMAT_RGBA5551,
147 DRM_FORMAT_RGBA4444,
148 DRM_FORMAT_RGB888,
149 DRM_FORMAT_RGB565,
150 DRM_FORMAT_NV12,
151 DRM_FORMAT_NV16,
152 DRM_FORMAT_NV21,
153 DRM_FORMAT_NV61,
154 DRM_FORMAT_UYVY,
155 DRM_FORMAT_VYUY,
156 DRM_FORMAT_XRGB8888,
157 DRM_FORMAT_YUV411,
158 DRM_FORMAT_YUV420,
159 DRM_FORMAT_YUV422,
160 DRM_FORMAT_YUV444,
161 DRM_FORMAT_YUYV,
162 DRM_FORMAT_YVU411,
163 DRM_FORMAT_YVU420,
164 DRM_FORMAT_YVU422,
165 DRM_FORMAT_YVU444,
166 DRM_FORMAT_YVYU,
167};
168
169static const uint32_t sun4i_backend_layer_formats[] = {
170 DRM_FORMAT_ARGB8888,
171 DRM_FORMAT_ARGB4444,
172 DRM_FORMAT_ARGB1555,
173 DRM_FORMAT_RGBA5551,
174 DRM_FORMAT_RGBA4444,
175 DRM_FORMAT_RGB888,
176 DRM_FORMAT_RGB565,
177 DRM_FORMAT_UYVY,
178 DRM_FORMAT_VYUY,
179 DRM_FORMAT_XRGB8888,
180 DRM_FORMAT_YUYV,
181 DRM_FORMAT_YVYU,
182};
183
184static const uint64_t sun4i_layer_modifiers[] = {
185 DRM_FORMAT_MOD_LINEAR,
186 DRM_FORMAT_MOD_ALLWINNER_TILED,
187 DRM_FORMAT_MOD_INVALID
188};
189
190static struct sun4i_layer *sun4i_layer_init_one(struct drm_device *drm,
191 struct sun4i_backend *backend,
192 enum drm_plane_type type,
193 unsigned int id)
194{
195 const uint64_t *modifiers = sun4i_layer_modifiers;
196 const uint32_t *formats = sun4i_layer_formats;
197 unsigned int formats_len = ARRAY_SIZE(sun4i_layer_formats);
198 struct sun4i_layer *layer;
199 int ret;
200
201 layer = devm_kzalloc(drm->dev, sizeof(*layer), GFP_KERNEL);
202 if (!layer)
203 return ERR_PTR(-ENOMEM);
204
205 layer->id = id;
206 layer->backend = backend;
207
208 if (IS_ERR_OR_NULL(backend->frontend)) {
209 formats = sun4i_backend_layer_formats;
210 formats_len = ARRAY_SIZE(sun4i_backend_layer_formats);
211 modifiers = NULL;
212 }
213
214 /* possible crtcs are set later */
215 ret = drm_universal_plane_init(drm, &layer->plane, 0,
216 &sun4i_backend_layer_funcs,
217 formats, formats_len,
218 modifiers, type, NULL);
219 if (ret) {
220 dev_err(drm->dev, "Couldn't initialize layer\n");
221 return ERR_PTR(ret);
222 }
223
224 drm_plane_helper_add(&layer->plane,
225 &sun4i_backend_layer_helper_funcs);
226
227 drm_plane_create_alpha_property(&layer->plane);
228 drm_plane_create_zpos_property(&layer->plane, layer->id,
229 0, SUN4I_BACKEND_NUM_LAYERS - 1);
230
231 return layer;
232}
233
234struct drm_plane **sun4i_layers_init(struct drm_device *drm,
235 struct sunxi_engine *engine)
236{
237 struct drm_plane **planes;
238 struct sun4i_backend *backend = engine_to_sun4i_backend(engine);
239 int i;
240
241 /* We need to have a sentinel at the need, hence the overallocation */
242 planes = devm_kcalloc(drm->dev, SUN4I_BACKEND_NUM_LAYERS + 1,
243 sizeof(*planes), GFP_KERNEL);
244 if (!planes)
245 return ERR_PTR(-ENOMEM);
246
247 for (i = 0; i < SUN4I_BACKEND_NUM_LAYERS; i++) {
248 enum drm_plane_type type = i ? DRM_PLANE_TYPE_OVERLAY : DRM_PLANE_TYPE_PRIMARY;
249 struct sun4i_layer *layer;
250
251 layer = sun4i_layer_init_one(drm, backend, type, i);
252 if (IS_ERR(layer)) {
253 dev_err(drm->dev, "Couldn't initialize %s plane\n",
254 i ? "overlay" : "primary");
255 return ERR_CAST(layer);
256 }
257
258 planes[i] = &layer->plane;
259 }
260
261 return planes;
262}
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}