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