1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/
4 * Author: Rob Clark <rob.clark@linaro.org>
5 */
6
7 #include <drm/drm_atomic.h>
8 #include <drm/drm_atomic_helper.h>
9 #include <drm/drm_plane_helper.h>
10
11 #include "omap_dmm_tiler.h"
12 #include "omap_drv.h"
13
14 /*
15 * plane funcs
16 */
17
18 #define to_omap_plane(x) container_of(x, struct omap_plane, base)
19
20 struct omap_plane {
21 struct drm_plane base;
22 enum omap_plane_id id;
23 const char *name;
24 };
25
omap_plane_prepare_fb(struct drm_plane * plane,struct drm_plane_state * new_state)26 static int omap_plane_prepare_fb(struct drm_plane *plane,
27 struct drm_plane_state *new_state)
28 {
29 if (!new_state->fb)
30 return 0;
31
32 return omap_framebuffer_pin(new_state->fb);
33 }
34
omap_plane_cleanup_fb(struct drm_plane * plane,struct drm_plane_state * old_state)35 static void omap_plane_cleanup_fb(struct drm_plane *plane,
36 struct drm_plane_state *old_state)
37 {
38 if (old_state->fb)
39 omap_framebuffer_unpin(old_state->fb);
40 }
41
omap_plane_atomic_update(struct drm_plane * plane,struct drm_atomic_state * state)42 static void omap_plane_atomic_update(struct drm_plane *plane,
43 struct drm_atomic_state *state)
44 {
45 struct omap_drm_private *priv = plane->dev->dev_private;
46 struct omap_plane *omap_plane = to_omap_plane(plane);
47 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
48 plane);
49 struct omap_overlay_info info;
50 int ret;
51
52 DBG("%s, crtc=%p fb=%p", omap_plane->name, new_state->crtc,
53 new_state->fb);
54
55 memset(&info, 0, sizeof(info));
56 info.rotation_type = OMAP_DSS_ROT_NONE;
57 info.rotation = DRM_MODE_ROTATE_0;
58 info.global_alpha = new_state->alpha >> 8;
59 info.zorder = new_state->normalized_zpos;
60 if (new_state->pixel_blend_mode == DRM_MODE_BLEND_PREMULTI)
61 info.pre_mult_alpha = 1;
62 else
63 info.pre_mult_alpha = 0;
64 info.color_encoding = new_state->color_encoding;
65 info.color_range = new_state->color_range;
66
67 /* update scanout: */
68 omap_framebuffer_update_scanout(new_state->fb, new_state, &info);
69
70 DBG("%dx%d -> %dx%d (%d)", info.width, info.height,
71 info.out_width, info.out_height,
72 info.screen_width);
73 DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
74 &info.paddr, &info.p_uv_addr);
75
76 /* and finally, update omapdss: */
77 ret = dispc_ovl_setup(priv->dispc, omap_plane->id, &info,
78 omap_crtc_timings(new_state->crtc), false,
79 omap_crtc_channel(new_state->crtc));
80 if (ret) {
81 dev_err(plane->dev->dev, "Failed to setup plane %s\n",
82 omap_plane->name);
83 dispc_ovl_enable(priv->dispc, omap_plane->id, false);
84 return;
85 }
86
87 dispc_ovl_enable(priv->dispc, omap_plane->id, true);
88 }
89
omap_plane_atomic_disable(struct drm_plane * plane,struct drm_atomic_state * state)90 static void omap_plane_atomic_disable(struct drm_plane *plane,
91 struct drm_atomic_state *state)
92 {
93 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
94 plane);
95 struct omap_drm_private *priv = plane->dev->dev_private;
96 struct omap_plane *omap_plane = to_omap_plane(plane);
97
98 new_state->rotation = DRM_MODE_ROTATE_0;
99 new_state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : omap_plane->id;
100
101 dispc_ovl_enable(priv->dispc, omap_plane->id, false);
102 }
103
omap_plane_atomic_check(struct drm_plane * plane,struct drm_atomic_state * state)104 static int omap_plane_atomic_check(struct drm_plane *plane,
105 struct drm_atomic_state *state)
106 {
107 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
108 plane);
109 struct drm_crtc_state *crtc_state;
110
111 if (!new_plane_state->fb)
112 return 0;
113
114 /* crtc should only be NULL when disabling (i.e., !new_plane_state->fb) */
115 if (WARN_ON(!new_plane_state->crtc))
116 return 0;
117
118 crtc_state = drm_atomic_get_existing_crtc_state(state,
119 new_plane_state->crtc);
120 /* we should have a crtc state if the plane is attached to a crtc */
121 if (WARN_ON(!crtc_state))
122 return 0;
123
124 if (!crtc_state->enable)
125 return 0;
126
127 if (new_plane_state->crtc_x < 0 || new_plane_state->crtc_y < 0)
128 return -EINVAL;
129
130 if (new_plane_state->crtc_x + new_plane_state->crtc_w > crtc_state->adjusted_mode.hdisplay)
131 return -EINVAL;
132
133 if (new_plane_state->crtc_y + new_plane_state->crtc_h > crtc_state->adjusted_mode.vdisplay)
134 return -EINVAL;
135
136 if (new_plane_state->rotation != DRM_MODE_ROTATE_0 &&
137 !omap_framebuffer_supports_rotation(new_plane_state->fb))
138 return -EINVAL;
139
140 return 0;
141 }
142
143 static const struct drm_plane_helper_funcs omap_plane_helper_funcs = {
144 .prepare_fb = omap_plane_prepare_fb,
145 .cleanup_fb = omap_plane_cleanup_fb,
146 .atomic_check = omap_plane_atomic_check,
147 .atomic_update = omap_plane_atomic_update,
148 .atomic_disable = omap_plane_atomic_disable,
149 };
150
omap_plane_destroy(struct drm_plane * plane)151 static void omap_plane_destroy(struct drm_plane *plane)
152 {
153 struct omap_plane *omap_plane = to_omap_plane(plane);
154
155 DBG("%s", omap_plane->name);
156
157 drm_plane_cleanup(plane);
158
159 kfree(omap_plane);
160 }
161
162 /* helper to install properties which are common to planes and crtcs */
omap_plane_install_properties(struct drm_plane * plane,struct drm_mode_object * obj)163 void omap_plane_install_properties(struct drm_plane *plane,
164 struct drm_mode_object *obj)
165 {
166 struct drm_device *dev = plane->dev;
167 struct omap_drm_private *priv = dev->dev_private;
168
169 if (priv->has_dmm) {
170 if (!plane->rotation_property)
171 drm_plane_create_rotation_property(plane,
172 DRM_MODE_ROTATE_0,
173 DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 |
174 DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270 |
175 DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y);
176
177 /* Attach the rotation property also to the crtc object */
178 if (plane->rotation_property && obj != &plane->base)
179 drm_object_attach_property(obj, plane->rotation_property,
180 DRM_MODE_ROTATE_0);
181 }
182
183 drm_object_attach_property(obj, priv->zorder_prop, 0);
184 }
185
omap_plane_reset(struct drm_plane * plane)186 static void omap_plane_reset(struct drm_plane *plane)
187 {
188 struct omap_plane *omap_plane = to_omap_plane(plane);
189
190 drm_atomic_helper_plane_reset(plane);
191 if (!plane->state)
192 return;
193
194 /*
195 * Set the zpos default depending on whether we are a primary or overlay
196 * plane.
197 */
198 plane->state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY
199 ? 0 : omap_plane->id;
200 plane->state->color_encoding = DRM_COLOR_YCBCR_BT601;
201 plane->state->color_range = DRM_COLOR_YCBCR_FULL_RANGE;
202 }
203
omap_plane_atomic_set_property(struct drm_plane * plane,struct drm_plane_state * state,struct drm_property * property,u64 val)204 static int omap_plane_atomic_set_property(struct drm_plane *plane,
205 struct drm_plane_state *state,
206 struct drm_property *property,
207 u64 val)
208 {
209 struct omap_drm_private *priv = plane->dev->dev_private;
210
211 if (property == priv->zorder_prop)
212 state->zpos = val;
213 else
214 return -EINVAL;
215
216 return 0;
217 }
218
omap_plane_atomic_get_property(struct drm_plane * plane,const struct drm_plane_state * state,struct drm_property * property,u64 * val)219 static int omap_plane_atomic_get_property(struct drm_plane *plane,
220 const struct drm_plane_state *state,
221 struct drm_property *property,
222 u64 *val)
223 {
224 struct omap_drm_private *priv = plane->dev->dev_private;
225
226 if (property == priv->zorder_prop)
227 *val = state->zpos;
228 else
229 return -EINVAL;
230
231 return 0;
232 }
233
234 static const struct drm_plane_funcs omap_plane_funcs = {
235 .update_plane = drm_atomic_helper_update_plane,
236 .disable_plane = drm_atomic_helper_disable_plane,
237 .reset = omap_plane_reset,
238 .destroy = omap_plane_destroy,
239 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
240 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
241 .atomic_set_property = omap_plane_atomic_set_property,
242 .atomic_get_property = omap_plane_atomic_get_property,
243 };
244
omap_plane_supports_yuv(struct drm_plane * plane)245 static bool omap_plane_supports_yuv(struct drm_plane *plane)
246 {
247 struct omap_drm_private *priv = plane->dev->dev_private;
248 struct omap_plane *omap_plane = to_omap_plane(plane);
249 const u32 *formats = dispc_ovl_get_color_modes(priv->dispc, omap_plane->id);
250 u32 i;
251
252 for (i = 0; formats[i]; i++)
253 if (formats[i] == DRM_FORMAT_YUYV ||
254 formats[i] == DRM_FORMAT_UYVY ||
255 formats[i] == DRM_FORMAT_NV12)
256 return true;
257
258 return false;
259 }
260
261 static const char *plane_id_to_name[] = {
262 [OMAP_DSS_GFX] = "gfx",
263 [OMAP_DSS_VIDEO1] = "vid1",
264 [OMAP_DSS_VIDEO2] = "vid2",
265 [OMAP_DSS_VIDEO3] = "vid3",
266 };
267
268 static const enum omap_plane_id plane_idx_to_id[] = {
269 OMAP_DSS_GFX,
270 OMAP_DSS_VIDEO1,
271 OMAP_DSS_VIDEO2,
272 OMAP_DSS_VIDEO3,
273 };
274
275 /* initialize plane */
omap_plane_init(struct drm_device * dev,int idx,enum drm_plane_type type,u32 possible_crtcs)276 struct drm_plane *omap_plane_init(struct drm_device *dev,
277 int idx, enum drm_plane_type type,
278 u32 possible_crtcs)
279 {
280 struct omap_drm_private *priv = dev->dev_private;
281 unsigned int num_planes = dispc_get_num_ovls(priv->dispc);
282 struct drm_plane *plane;
283 struct omap_plane *omap_plane;
284 enum omap_plane_id id;
285 int ret;
286 u32 nformats;
287 const u32 *formats;
288
289 if (WARN_ON(idx >= ARRAY_SIZE(plane_idx_to_id)))
290 return ERR_PTR(-EINVAL);
291
292 id = plane_idx_to_id[idx];
293
294 DBG("%s: type=%d", plane_id_to_name[id], type);
295
296 omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
297 if (!omap_plane)
298 return ERR_PTR(-ENOMEM);
299
300 formats = dispc_ovl_get_color_modes(priv->dispc, id);
301 for (nformats = 0; formats[nformats]; ++nformats)
302 ;
303 omap_plane->id = id;
304 omap_plane->name = plane_id_to_name[id];
305
306 plane = &omap_plane->base;
307
308 ret = drm_universal_plane_init(dev, plane, possible_crtcs,
309 &omap_plane_funcs, formats,
310 nformats, NULL, type, NULL);
311 if (ret < 0)
312 goto error;
313
314 drm_plane_helper_add(plane, &omap_plane_helper_funcs);
315
316 omap_plane_install_properties(plane, &plane->base);
317 drm_plane_create_zpos_property(plane, 0, 0, num_planes - 1);
318 drm_plane_create_alpha_property(plane);
319 drm_plane_create_blend_mode_property(plane, BIT(DRM_MODE_BLEND_PREMULTI) |
320 BIT(DRM_MODE_BLEND_COVERAGE));
321
322 if (omap_plane_supports_yuv(plane))
323 drm_plane_create_color_properties(plane,
324 BIT(DRM_COLOR_YCBCR_BT601) |
325 BIT(DRM_COLOR_YCBCR_BT709),
326 BIT(DRM_COLOR_YCBCR_FULL_RANGE) |
327 BIT(DRM_COLOR_YCBCR_LIMITED_RANGE),
328 DRM_COLOR_YCBCR_BT601,
329 DRM_COLOR_YCBCR_FULL_RANGE);
330
331 return plane;
332
333 error:
334 dev_err(dev->dev, "%s(): could not create plane: %s\n",
335 __func__, plane_id_to_name[id]);
336
337 kfree(omap_plane);
338 return NULL;
339 }
340