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_blend.h>
10 #include <drm/drm_gem_atomic_helper.h>
11 #include <drm/drm_fourcc.h>
12 #include <drm/drm_framebuffer.h>
13 
14 #include "omap_dmm_tiler.h"
15 #include "omap_drv.h"
16 
17 /*
18  * plane funcs
19  */
20 
21 #define to_omap_plane_state(x) container_of(x, struct omap_plane_state, base)
22 
23 struct omap_plane_state {
24 	/* Must be first. */
25 	struct drm_plane_state base;
26 
27 	struct omap_hw_overlay *overlay;
28 	struct omap_hw_overlay *r_overlay;  /* right overlay */
29 };
30 
31 #define to_omap_plane(x) container_of(x, struct omap_plane, base)
32 
33 struct omap_plane {
34 	struct drm_plane base;
35 	enum omap_plane_id id;
36 };
37 
38 bool is_omap_plane_dual_overlay(struct drm_plane_state *state)
39 {
40 	struct omap_plane_state *omap_state = to_omap_plane_state(state);
41 
42 	return !!omap_state->r_overlay;
43 }
44 
45 static int omap_plane_prepare_fb(struct drm_plane *plane,
46 				 struct drm_plane_state *new_state)
47 {
48 	if (!new_state->fb)
49 		return 0;
50 
51 	drm_gem_plane_helper_prepare_fb(plane, new_state);
52 
53 	return omap_framebuffer_pin(new_state->fb);
54 }
55 
56 static void omap_plane_cleanup_fb(struct drm_plane *plane,
57 				  struct drm_plane_state *old_state)
58 {
59 	if (old_state->fb)
60 		omap_framebuffer_unpin(old_state->fb);
61 }
62 
63 static void omap_plane_atomic_update(struct drm_plane *plane,
64 				     struct drm_atomic_state *state)
65 {
66 	struct omap_drm_private *priv = plane->dev->dev_private;
67 	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
68 									   plane);
69 	struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
70 									   plane);
71 	struct omap_plane_state *new_omap_state;
72 	struct omap_plane_state *old_omap_state;
73 	struct omap_overlay_info info, r_info;
74 	enum omap_plane_id ovl_id, r_ovl_id;
75 	int ret;
76 	bool dual_ovl;
77 
78 	new_omap_state = to_omap_plane_state(new_state);
79 	old_omap_state = to_omap_plane_state(old_state);
80 
81 	dual_ovl = is_omap_plane_dual_overlay(new_state);
82 
83 	/* Cleanup previously held overlay if needed */
84 	if (old_omap_state->overlay)
85 		omap_overlay_update_state(priv, old_omap_state->overlay);
86 	if (old_omap_state->r_overlay)
87 		omap_overlay_update_state(priv, old_omap_state->r_overlay);
88 
89 	if (!new_omap_state->overlay) {
90 		DBG("[PLANE:%d:%s] no overlay attached", plane->base.id, plane->name);
91 		return;
92 	}
93 
94 	ovl_id = new_omap_state->overlay->id;
95 	DBG("%s, crtc=%p fb=%p", plane->name, new_state->crtc,
96 	    new_state->fb);
97 
98 	memset(&info, 0, sizeof(info));
99 	info.rotation_type = OMAP_DSS_ROT_NONE;
100 	info.rotation = DRM_MODE_ROTATE_0;
101 	info.global_alpha = new_state->alpha >> 8;
102 	info.zorder = new_state->normalized_zpos;
103 	if (new_state->pixel_blend_mode == DRM_MODE_BLEND_PREMULTI)
104 		info.pre_mult_alpha = 1;
105 	else
106 		info.pre_mult_alpha = 0;
107 	info.color_encoding = new_state->color_encoding;
108 	info.color_range = new_state->color_range;
109 
110 	r_info = info;
111 
112 	/* update scanout: */
113 	omap_framebuffer_update_scanout(new_state->fb, new_state, &info,
114 					dual_ovl ? &r_info : NULL);
115 
116 	DBG("%s: %dx%d -> %dx%d (%d)",
117 			new_omap_state->overlay->name, info.width, info.height,
118 			info.out_width, info.out_height, info.screen_width);
119 	DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
120 			&info.paddr, &info.p_uv_addr);
121 
122 	if (dual_ovl) {
123 		r_ovl_id = new_omap_state->r_overlay->id;
124 		/*
125 		 * If the current plane uses 2 hw planes the very next
126 		 * zorder is used by the r_overlay so we just use the
127 		 * main overlay zorder + 1
128 		 */
129 		r_info.zorder = info.zorder + 1;
130 
131 		DBG("%s: %dx%d -> %dx%d (%d)",
132 		    new_omap_state->r_overlay->name,
133 		    r_info.width, r_info.height,
134 		    r_info.out_width, r_info.out_height, r_info.screen_width);
135 		DBG("%d,%d %pad %pad", r_info.pos_x, r_info.pos_y,
136 		    &r_info.paddr, &r_info.p_uv_addr);
137 	}
138 
139 	/* and finally, update omapdss: */
140 	ret = dispc_ovl_setup(priv->dispc, ovl_id, &info,
141 			      omap_crtc_timings(new_state->crtc), false,
142 			      omap_crtc_channel(new_state->crtc));
143 	if (ret) {
144 		dev_err(plane->dev->dev, "Failed to setup plane %s\n",
145 			plane->name);
146 		dispc_ovl_enable(priv->dispc, ovl_id, false);
147 		return;
148 	}
149 
150 	dispc_ovl_enable(priv->dispc, ovl_id, true);
151 
152 	if (dual_ovl) {
153 		ret = dispc_ovl_setup(priv->dispc, r_ovl_id, &r_info,
154 				      omap_crtc_timings(new_state->crtc), false,
155 				      omap_crtc_channel(new_state->crtc));
156 		if (ret) {
157 			dev_err(plane->dev->dev, "Failed to setup plane right-overlay %s\n",
158 				plane->name);
159 			dispc_ovl_enable(priv->dispc, r_ovl_id, false);
160 			dispc_ovl_enable(priv->dispc, ovl_id, false);
161 			return;
162 		}
163 
164 		dispc_ovl_enable(priv->dispc, r_ovl_id, true);
165 	}
166 }
167 
168 static void omap_plane_atomic_disable(struct drm_plane *plane,
169 				      struct drm_atomic_state *state)
170 {
171 	struct omap_drm_private *priv = plane->dev->dev_private;
172 	struct omap_plane *omap_plane = to_omap_plane(plane);
173 	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
174 									   plane);
175 	struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
176 									   plane);
177 	struct omap_plane_state *new_omap_state;
178 	struct omap_plane_state *old_omap_state;
179 
180 	new_omap_state = to_omap_plane_state(new_state);
181 	old_omap_state = to_omap_plane_state(old_state);
182 
183 	if (!old_omap_state->overlay)
184 		return;
185 
186 	new_state->rotation = DRM_MODE_ROTATE_0;
187 	new_state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : omap_plane->id;
188 
189 	omap_overlay_update_state(priv, old_omap_state->overlay);
190 	new_omap_state->overlay = NULL;
191 
192 	if (is_omap_plane_dual_overlay(old_state)) {
193 		omap_overlay_update_state(priv, old_omap_state->r_overlay);
194 		new_omap_state->r_overlay = NULL;
195 	}
196 }
197 
198 #define FRAC_16_16(mult, div)    (((mult) << 16) / (div))
199 
200 static int omap_plane_atomic_check(struct drm_plane *plane,
201 				   struct drm_atomic_state *state)
202 {
203 	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
204 										 plane);
205 	struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
206 										 plane);
207 	struct omap_drm_private *priv = plane->dev->dev_private;
208 	struct omap_plane_state *omap_state = to_omap_plane_state(new_plane_state);
209 	struct omap_global_state *omap_overlay_global_state;
210 	struct drm_crtc_state *crtc_state;
211 	bool new_r_hw_overlay = false;
212 	bool new_hw_overlay = false;
213 	u32 max_width, max_height;
214 	struct drm_crtc *crtc;
215 	u16 width, height;
216 	u32 caps = 0;
217 	u32 fourcc;
218 	int ret;
219 
220 	omap_overlay_global_state = omap_get_global_state(state);
221 	if (IS_ERR(omap_overlay_global_state))
222 		return PTR_ERR(omap_overlay_global_state);
223 
224 	dispc_ovl_get_max_size(priv->dispc, &width, &height);
225 	max_width = width << 16;
226 	max_height = height << 16;
227 
228 	crtc = new_plane_state->crtc ? new_plane_state->crtc : plane->state->crtc;
229 	if (!crtc)
230 		return 0;
231 
232 	crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
233 	/* we should have a crtc state if the plane is attached to a crtc */
234 	if (WARN_ON(!crtc_state))
235 		return 0;
236 
237 	/*
238 	 * Note: these are just sanity checks to filter out totally bad scaling
239 	 * factors. The real limits must be calculated case by case, and
240 	 * unfortunately we currently do those checks only at the commit
241 	 * phase in dispc.
242 	 */
243 	ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
244 						  FRAC_16_16(1, 8), FRAC_16_16(8, 1),
245 						  true, true);
246 	if (ret)
247 		return ret;
248 
249 	DBG("%s: visible %d -> %d", plane->name,
250 	    old_plane_state->visible, new_plane_state->visible);
251 
252 	if (!new_plane_state->visible) {
253 		omap_overlay_release(state, omap_state->overlay);
254 		omap_overlay_release(state, omap_state->r_overlay);
255 		omap_state->overlay = NULL;
256 		omap_state->r_overlay = NULL;
257 		return 0;
258 	}
259 
260 	if (new_plane_state->crtc_x < 0 || new_plane_state->crtc_y < 0)
261 		return -EINVAL;
262 
263 	if (new_plane_state->crtc_x + new_plane_state->crtc_w > crtc_state->adjusted_mode.hdisplay)
264 		return -EINVAL;
265 
266 	if (new_plane_state->crtc_y + new_plane_state->crtc_h > crtc_state->adjusted_mode.vdisplay)
267 		return -EINVAL;
268 
269 	/* Make sure dimensions are within bounds. */
270 	if (new_plane_state->src_h > max_height || new_plane_state->crtc_h > height)
271 		return -EINVAL;
272 
273 
274 	if (new_plane_state->src_w > max_width || new_plane_state->crtc_w > width) {
275 		bool is_fourcc_yuv = new_plane_state->fb->format->is_yuv;
276 
277 		if (is_fourcc_yuv && (((new_plane_state->src_w >> 16) / 2 & 1) ||
278 				      new_plane_state->crtc_w / 2 & 1)) {
279 			/*
280 			 * When calculating the split overlay width
281 			 * and it yield an odd value we will need to adjust
282 			 * the indivual width +/- 1. So make sure it fits
283 			 */
284 			if (new_plane_state->src_w <= ((2 * width - 1) << 16) &&
285 			    new_plane_state->crtc_w <= (2 * width - 1))
286 				new_r_hw_overlay = true;
287 			else
288 				return -EINVAL;
289 		} else {
290 			if (new_plane_state->src_w <= (2 * max_width) &&
291 			    new_plane_state->crtc_w <= (2 * width))
292 				new_r_hw_overlay = true;
293 			else
294 				return -EINVAL;
295 		}
296 	}
297 
298 	if (new_plane_state->rotation != DRM_MODE_ROTATE_0 &&
299 	    !omap_framebuffer_supports_rotation(new_plane_state->fb))
300 		return -EINVAL;
301 
302 	if ((new_plane_state->src_w >> 16) != new_plane_state->crtc_w ||
303 	    (new_plane_state->src_h >> 16) != new_plane_state->crtc_h)
304 		caps |= OMAP_DSS_OVL_CAP_SCALE;
305 
306 	fourcc = new_plane_state->fb->format->format;
307 
308 	/*
309 	 * (re)allocate hw overlay if we don't have one or
310 	 * there is a caps mismatch
311 	 */
312 	if (!omap_state->overlay || (caps & ~omap_state->overlay->caps)) {
313 		new_hw_overlay = true;
314 	} else {
315 		/* check supported format */
316 		if (!dispc_ovl_color_mode_supported(priv->dispc, omap_state->overlay->id,
317 						    fourcc))
318 			new_hw_overlay = true;
319 	}
320 
321 	/*
322 	 * check if we need two overlays and only have 1 or
323 	 * if we had 2 overlays but will only need 1
324 	 */
325 	if ((new_r_hw_overlay && !omap_state->r_overlay) ||
326 	    (!new_r_hw_overlay && omap_state->r_overlay))
327 		new_hw_overlay = true;
328 
329 	if (new_hw_overlay) {
330 		struct omap_hw_overlay *old_ovl = omap_state->overlay;
331 		struct omap_hw_overlay *old_r_ovl = omap_state->r_overlay;
332 		struct omap_hw_overlay *new_ovl = NULL;
333 		struct omap_hw_overlay *new_r_ovl = NULL;
334 
335 		omap_overlay_release(state, old_ovl);
336 		omap_overlay_release(state, old_r_ovl);
337 
338 		ret = omap_overlay_assign(state, plane, caps, fourcc, &new_ovl,
339 					  new_r_hw_overlay ? &new_r_ovl : NULL);
340 		if (ret) {
341 			DBG("%s: failed to assign hw_overlay", plane->name);
342 			omap_state->overlay = NULL;
343 			omap_state->r_overlay = NULL;
344 			return ret;
345 		}
346 
347 		omap_state->overlay = new_ovl;
348 		if (new_r_hw_overlay)
349 			omap_state->r_overlay = new_r_ovl;
350 		else
351 			omap_state->r_overlay = NULL;
352 	}
353 
354 	DBG("plane: %s overlay_id: %d", plane->name, omap_state->overlay->id);
355 
356 	if (omap_state->r_overlay)
357 		DBG("plane: %s r_overlay_id: %d", plane->name, omap_state->r_overlay->id);
358 
359 	return 0;
360 }
361 
362 static const struct drm_plane_helper_funcs omap_plane_helper_funcs = {
363 	.prepare_fb = omap_plane_prepare_fb,
364 	.cleanup_fb = omap_plane_cleanup_fb,
365 	.atomic_check = omap_plane_atomic_check,
366 	.atomic_update = omap_plane_atomic_update,
367 	.atomic_disable = omap_plane_atomic_disable,
368 };
369 
370 static void omap_plane_destroy(struct drm_plane *plane)
371 {
372 	struct omap_plane *omap_plane = to_omap_plane(plane);
373 
374 	DBG("%s", plane->name);
375 
376 	drm_plane_cleanup(plane);
377 
378 	kfree(omap_plane);
379 }
380 
381 /* helper to install properties which are common to planes and crtcs */
382 void omap_plane_install_properties(struct drm_plane *plane,
383 		struct drm_mode_object *obj)
384 {
385 	struct drm_device *dev = plane->dev;
386 	struct omap_drm_private *priv = dev->dev_private;
387 
388 	if (priv->has_dmm) {
389 		if (!plane->rotation_property)
390 			drm_plane_create_rotation_property(plane,
391 							   DRM_MODE_ROTATE_0,
392 							   DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 |
393 							   DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270 |
394 							   DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y);
395 
396 		/* Attach the rotation property also to the crtc object */
397 		if (plane->rotation_property && obj != &plane->base)
398 			drm_object_attach_property(obj, plane->rotation_property,
399 						   DRM_MODE_ROTATE_0);
400 	}
401 
402 	drm_object_attach_property(obj, priv->zorder_prop, 0);
403 }
404 
405 static void omap_plane_reset(struct drm_plane *plane)
406 {
407 	struct omap_plane_state *omap_state;
408 
409 	if (plane->state)
410 		drm_atomic_helper_plane_destroy_state(plane, plane->state);
411 
412 	omap_state = kzalloc(sizeof(*omap_state), GFP_KERNEL);
413 	if (!omap_state)
414 		return;
415 
416 	__drm_atomic_helper_plane_reset(plane, &omap_state->base);
417 }
418 
419 static struct drm_plane_state *
420 omap_plane_atomic_duplicate_state(struct drm_plane *plane)
421 {
422 	struct omap_plane_state *state, *current_state;
423 
424 	if (WARN_ON(!plane->state))
425 		return NULL;
426 
427 	current_state = to_omap_plane_state(plane->state);
428 
429 	state = kmalloc(sizeof(*state), GFP_KERNEL);
430 	if (!state)
431 		return NULL;
432 
433 	__drm_atomic_helper_plane_duplicate_state(plane, &state->base);
434 
435 	state->overlay = current_state->overlay;
436 	state->r_overlay = current_state->r_overlay;
437 
438 	return &state->base;
439 }
440 
441 static void omap_plane_atomic_print_state(struct drm_printer *p,
442 					  const struct drm_plane_state *state)
443 {
444 	struct omap_plane_state *omap_state = to_omap_plane_state(state);
445 
446 	if (omap_state->overlay)
447 		drm_printf(p, "\toverlay=%s (caps=0x%x)\n",
448 			   omap_state->overlay->name,
449 			   omap_state->overlay->caps);
450 	else
451 		drm_printf(p, "\toverlay=None\n");
452 	if (omap_state->r_overlay)
453 		drm_printf(p, "\tr_overlay=%s (caps=0x%x)\n",
454 			   omap_state->r_overlay->name,
455 			   omap_state->r_overlay->caps);
456 	else
457 		drm_printf(p, "\tr_overlay=None\n");
458 }
459 
460 static int omap_plane_atomic_set_property(struct drm_plane *plane,
461 					  struct drm_plane_state *state,
462 					  struct drm_property *property,
463 					  u64 val)
464 {
465 	struct omap_drm_private *priv = plane->dev->dev_private;
466 
467 	if (property == priv->zorder_prop)
468 		state->zpos = val;
469 	else
470 		return -EINVAL;
471 
472 	return 0;
473 }
474 
475 static int omap_plane_atomic_get_property(struct drm_plane *plane,
476 					  const struct drm_plane_state *state,
477 					  struct drm_property *property,
478 					  u64 *val)
479 {
480 	struct omap_drm_private *priv = plane->dev->dev_private;
481 
482 	if (property == priv->zorder_prop)
483 		*val = state->zpos;
484 	else
485 		return -EINVAL;
486 
487 	return 0;
488 }
489 
490 static const struct drm_plane_funcs omap_plane_funcs = {
491 	.update_plane = drm_atomic_helper_update_plane,
492 	.disable_plane = drm_atomic_helper_disable_plane,
493 	.reset = omap_plane_reset,
494 	.destroy = omap_plane_destroy,
495 	.atomic_duplicate_state = omap_plane_atomic_duplicate_state,
496 	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
497 	.atomic_set_property = omap_plane_atomic_set_property,
498 	.atomic_get_property = omap_plane_atomic_get_property,
499 	.atomic_print_state = omap_plane_atomic_print_state,
500 };
501 
502 static bool omap_plane_supports_yuv(struct drm_plane *plane)
503 {
504 	struct omap_drm_private *priv = plane->dev->dev_private;
505 	struct omap_plane *omap_plane = to_omap_plane(plane);
506 	const u32 *formats = dispc_ovl_get_color_modes(priv->dispc, omap_plane->id);
507 	u32 i;
508 
509 	for (i = 0; formats[i]; i++)
510 		if (formats[i] == DRM_FORMAT_YUYV ||
511 		    formats[i] == DRM_FORMAT_UYVY ||
512 		    formats[i] == DRM_FORMAT_NV12)
513 			return true;
514 
515 	return false;
516 }
517 
518 /* initialize plane */
519 struct drm_plane *omap_plane_init(struct drm_device *dev,
520 		int idx, enum drm_plane_type type,
521 		u32 possible_crtcs)
522 {
523 	struct omap_drm_private *priv = dev->dev_private;
524 	unsigned int num_planes = dispc_get_num_ovls(priv->dispc);
525 	struct drm_plane *plane;
526 	struct omap_plane *omap_plane;
527 	unsigned int zpos;
528 	int ret;
529 	u32 nformats;
530 	const u32 *formats;
531 
532 	if (WARN_ON(idx >= num_planes))
533 		return ERR_PTR(-EINVAL);
534 
535 	omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
536 	if (!omap_plane)
537 		return ERR_PTR(-ENOMEM);
538 
539 	omap_plane->id = idx;
540 
541 	DBG("%d: type=%d", omap_plane->id, type);
542 	DBG("	crtc_mask: 0x%04x", possible_crtcs);
543 
544 	formats = dispc_ovl_get_color_modes(priv->dispc, omap_plane->id);
545 	for (nformats = 0; formats[nformats]; ++nformats)
546 		;
547 
548 	plane = &omap_plane->base;
549 
550 	ret = drm_universal_plane_init(dev, plane, possible_crtcs,
551 				       &omap_plane_funcs, formats,
552 				       nformats, NULL, type, NULL);
553 	if (ret < 0)
554 		goto error;
555 
556 	drm_plane_helper_add(plane, &omap_plane_helper_funcs);
557 
558 	omap_plane_install_properties(plane, &plane->base);
559 
560 	/*
561 	 * Set the zpos default depending on whether we are a primary or overlay
562 	 * plane.
563 	 */
564 	if (plane->type == DRM_PLANE_TYPE_PRIMARY)
565 		zpos = 0;
566 	else
567 		zpos = omap_plane->id;
568 	drm_plane_create_zpos_property(plane, zpos, 0, num_planes - 1);
569 	drm_plane_create_alpha_property(plane);
570 	drm_plane_create_blend_mode_property(plane, BIT(DRM_MODE_BLEND_PREMULTI) |
571 					     BIT(DRM_MODE_BLEND_COVERAGE));
572 
573 	if (omap_plane_supports_yuv(plane))
574 		drm_plane_create_color_properties(plane,
575 						  BIT(DRM_COLOR_YCBCR_BT601) |
576 						  BIT(DRM_COLOR_YCBCR_BT709),
577 						  BIT(DRM_COLOR_YCBCR_FULL_RANGE) |
578 						  BIT(DRM_COLOR_YCBCR_LIMITED_RANGE),
579 						  DRM_COLOR_YCBCR_BT601,
580 						  DRM_COLOR_YCBCR_FULL_RANGE);
581 
582 	return plane;
583 
584 error:
585 	dev_err(dev->dev, "%s(): could not create plane: %d\n",
586 		__func__, omap_plane->id);
587 
588 	kfree(omap_plane);
589 	return NULL;
590 }
591