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