dcss-plane.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright 2019 NXP.
  4 */
  5
  6#include <drm/drm_atomic.h>
  7#include <drm/drm_atomic_helper.h>
  8#include <drm/drm_blend.h>
  9#include <drm/drm_fb_dma_helper.h>
 10#include <drm/drm_framebuffer.h>
 11#include <drm/drm_gem_atomic_helper.h>
 12#include <drm/drm_gem_dma_helper.h>
 13#include <drm/drm_print.h>
 14
 15#include "dcss-dev.h"
 16#include "dcss-kms.h"
 17
 18static const u32 dcss_common_formats[] = {
 19	/* RGB */
 20	DRM_FORMAT_ARGB8888,
 21	DRM_FORMAT_XRGB8888,
 22	DRM_FORMAT_ABGR8888,
 23	DRM_FORMAT_XBGR8888,
 24	DRM_FORMAT_RGBA8888,
 25	DRM_FORMAT_RGBX8888,
 26	DRM_FORMAT_BGRA8888,
 27	DRM_FORMAT_BGRX8888,
 28	DRM_FORMAT_XRGB2101010,
 29	DRM_FORMAT_XBGR2101010,
 30	DRM_FORMAT_RGBX1010102,
 31	DRM_FORMAT_BGRX1010102,
 32	DRM_FORMAT_ARGB2101010,
 33	DRM_FORMAT_ABGR2101010,
 34	DRM_FORMAT_RGBA1010102,
 35	DRM_FORMAT_BGRA1010102,
 36};
 37
 38static const u64 dcss_video_format_modifiers[] = {
 39	DRM_FORMAT_MOD_LINEAR,
 40	DRM_FORMAT_MOD_INVALID,
 41};
 42
 43static const u64 dcss_graphics_format_modifiers[] = {
 44	DRM_FORMAT_MOD_VIVANTE_TILED,
 45	DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
 46	DRM_FORMAT_MOD_LINEAR,
 47	DRM_FORMAT_MOD_INVALID,
 48};
 49
 50static inline struct dcss_plane *to_dcss_plane(struct drm_plane *p)
 51{
 52	return container_of(p, struct dcss_plane, base);
 53}
 54
 55static inline bool dcss_plane_fb_is_linear(const struct drm_framebuffer *fb)
 56{
 57	return ((fb->flags & DRM_MODE_FB_MODIFIERS) == 0) ||
 58	       ((fb->flags & DRM_MODE_FB_MODIFIERS) != 0 &&
 59		fb->modifier == DRM_FORMAT_MOD_LINEAR);
 60}
 61
 62static void dcss_plane_destroy(struct drm_plane *plane)
 63{
 64	struct dcss_plane *dcss_plane = container_of(plane, struct dcss_plane,
 65						     base);
 66
 67	drm_plane_cleanup(plane);
 68	kfree(dcss_plane);
 69}
 70
 71static bool dcss_plane_format_mod_supported(struct drm_plane *plane,
 72					    u32 format,
 73					    u64 modifier)
 74{
 75	switch (plane->type) {
 76	case DRM_PLANE_TYPE_PRIMARY:
 77		switch (format) {
 78		case DRM_FORMAT_ARGB8888:
 79		case DRM_FORMAT_XRGB8888:
 80		case DRM_FORMAT_ARGB2101010:
 81			return modifier == DRM_FORMAT_MOD_LINEAR ||
 82			       modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
 83			       modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED;
 84		default:
 85			return modifier == DRM_FORMAT_MOD_LINEAR;
 86		}
 87		break;
 88	case DRM_PLANE_TYPE_OVERLAY:
 89		return modifier == DRM_FORMAT_MOD_LINEAR;
 90	default:
 91		return false;
 92	}
 93}
 94
 95static const struct drm_plane_funcs dcss_plane_funcs = {
 96	.update_plane		= drm_atomic_helper_update_plane,
 97	.disable_plane		= drm_atomic_helper_disable_plane,
 98	.destroy		= dcss_plane_destroy,
 99	.reset			= drm_atomic_helper_plane_reset,
100	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
101	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
102	.format_mod_supported	= dcss_plane_format_mod_supported,
103};
104
105static bool dcss_plane_can_rotate(const struct drm_format_info *format,
106				  bool mod_present, u64 modifier,
107				  unsigned int rotation)
108{
109	bool linear_format = !mod_present || modifier == DRM_FORMAT_MOD_LINEAR;
110	u32 supported_rotation = DRM_MODE_ROTATE_0;
111
112	if (!format->is_yuv && linear_format)
113		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
114				     DRM_MODE_REFLECT_MASK;
115	else if (!format->is_yuv &&
116		 (modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
117		  modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED))
118		supported_rotation = DRM_MODE_ROTATE_MASK |
119				     DRM_MODE_REFLECT_MASK;
120	else if (format->is_yuv && linear_format &&
121		 (format->format == DRM_FORMAT_NV12 ||
122		  format->format == DRM_FORMAT_NV21))
123		supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
124				     DRM_MODE_REFLECT_MASK;
125
126	return !!(rotation & supported_rotation);
127}
128
129static bool dcss_plane_is_source_size_allowed(u16 src_w, u16 src_h, u32 pix_fmt)
130{
131	if (src_w < 64 &&
132	    (pix_fmt == DRM_FORMAT_NV12 || pix_fmt == DRM_FORMAT_NV21))
133		return false;
134	else if (src_w < 32 &&
135		 (pix_fmt == DRM_FORMAT_UYVY || pix_fmt == DRM_FORMAT_VYUY ||
136		  pix_fmt == DRM_FORMAT_YUYV || pix_fmt == DRM_FORMAT_YVYU))
137		return false;
138
139	return src_w >= 16 && src_h >= 8;
140}
141
142static int dcss_plane_atomic_check(struct drm_plane *plane,
143				   struct drm_atomic_state *state)
144{
145	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
146										 plane);
147	struct dcss_plane *dcss_plane = to_dcss_plane(plane);
148	struct dcss_dev *dcss = plane->dev->dev_private;
149	struct drm_framebuffer *fb = new_plane_state->fb;
150	bool is_primary_plane = plane->type == DRM_PLANE_TYPE_PRIMARY;
151	struct drm_gem_dma_object *dma_obj;
152	struct drm_crtc_state *crtc_state;
153	int hdisplay, vdisplay;
154	int min, max;
155	int ret;
156
157	if (!fb || !new_plane_state->crtc)
158		return 0;
159
160	dma_obj = drm_fb_dma_get_gem_obj(fb, 0);
161	WARN_ON(!dma_obj);
162
163	crtc_state = drm_atomic_get_new_crtc_state(state,
164						   new_plane_state->crtc);
165
166	hdisplay = crtc_state->adjusted_mode.hdisplay;
167	vdisplay = crtc_state->adjusted_mode.vdisplay;
168
169	if (!dcss_plane_is_source_size_allowed(new_plane_state->src_w >> 16,
170					       new_plane_state->src_h >> 16,
171					       fb->format->format)) {
172		DRM_DEBUG_KMS("Source plane size is not allowed!\n");
173		return -EINVAL;
174	}
175
176	dcss_scaler_get_min_max_ratios(dcss->scaler, dcss_plane->ch_num,
177				       &min, &max);
178
179	ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
180						  min, max, !is_primary_plane,
181						  false);
182	if (ret)
183		return ret;
184
185	if (!new_plane_state->visible)
186		return 0;
187
188	if (!dcss_plane_can_rotate(fb->format,
189				   !!(fb->flags & DRM_MODE_FB_MODIFIERS),
190				   fb->modifier,
191				   new_plane_state->rotation)) {
192		DRM_DEBUG_KMS("requested rotation is not allowed!\n");
193		return -EINVAL;
194	}
195
196	if ((new_plane_state->crtc_x < 0 || new_plane_state->crtc_y < 0 ||
197	     new_plane_state->crtc_x + new_plane_state->crtc_w > hdisplay ||
198	     new_plane_state->crtc_y + new_plane_state->crtc_h > vdisplay) &&
199	    !dcss_plane_fb_is_linear(fb)) {
200		DRM_DEBUG_KMS("requested cropping operation is not allowed!\n");
201		return -EINVAL;
202	}
203
204	if ((fb->flags & DRM_MODE_FB_MODIFIERS) &&
205	    !plane->funcs->format_mod_supported(plane,
206				fb->format->format,
207				fb->modifier)) {
208		DRM_DEBUG_KMS("Invalid modifier: %llx", fb->modifier);
209		return -EINVAL;
210	}
211
212	return 0;
213}
214
215static void dcss_plane_atomic_set_base(struct dcss_plane *dcss_plane)
216{
217	struct drm_plane *plane = &dcss_plane->base;
218	struct drm_plane_state *state = plane->state;
219	struct dcss_dev *dcss = plane->dev->dev_private;
220	struct drm_framebuffer *fb = state->fb;
221	const struct drm_format_info *format = fb->format;
222	struct drm_gem_dma_object *dma_obj = drm_fb_dma_get_gem_obj(fb, 0);
223	unsigned long p1_ba = 0, p2_ba = 0;
224
225	if (!format->is_yuv ||
226	    format->format == DRM_FORMAT_NV12 ||
227	    format->format == DRM_FORMAT_NV21)
228		p1_ba = dma_obj->dma_addr + fb->offsets[0] +
229			fb->pitches[0] * (state->src.y1 >> 16) +
230			format->char_per_block[0] * (state->src.x1 >> 16);
231	else if (format->format == DRM_FORMAT_UYVY ||
232		 format->format == DRM_FORMAT_VYUY ||
233		 format->format == DRM_FORMAT_YUYV ||
234		 format->format == DRM_FORMAT_YVYU)
235		p1_ba = dma_obj->dma_addr + fb->offsets[0] +
236			fb->pitches[0] * (state->src.y1 >> 16) +
237			2 * format->char_per_block[0] * (state->src.x1 >> 17);
238
239	if (format->format == DRM_FORMAT_NV12 ||
240	    format->format == DRM_FORMAT_NV21)
241		p2_ba = dma_obj->dma_addr + fb->offsets[1] +
242			(((fb->pitches[1] >> 1) * (state->src.y1 >> 17) +
243			(state->src.x1 >> 17)) << 1);
244
245	dcss_dpr_addr_set(dcss->dpr, dcss_plane->ch_num, p1_ba, p2_ba,
246			  fb->pitches[0]);
247}
248
249static bool dcss_plane_needs_setup(struct drm_plane_state *state,
250				   struct drm_plane_state *old_state)
251{
252	struct drm_framebuffer *fb = state->fb;
253	struct drm_framebuffer *old_fb = old_state->fb;
254
255	return state->crtc_x != old_state->crtc_x ||
256	       state->crtc_y != old_state->crtc_y ||
257	       state->crtc_w != old_state->crtc_w ||
258	       state->crtc_h != old_state->crtc_h ||
259	       state->src_x  != old_state->src_x  ||
260	       state->src_y  != old_state->src_y  ||
261	       state->src_w  != old_state->src_w  ||
262	       state->src_h  != old_state->src_h  ||
263	       fb->format->format != old_fb->format->format ||
264	       fb->modifier  != old_fb->modifier ||
265	       state->rotation != old_state->rotation ||
266	       state->scaling_filter != old_state->scaling_filter;
267}
268
269static void dcss_plane_atomic_update(struct drm_plane *plane,
270				     struct drm_atomic_state *state)
271{
272	struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
273									   plane);
274	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
275									   plane);
276	struct dcss_plane *dcss_plane = to_dcss_plane(plane);
277	struct dcss_dev *dcss = plane->dev->dev_private;
278	struct drm_framebuffer *fb = new_state->fb;
279	struct drm_crtc_state *crtc_state;
280	bool modifiers_present;
281	u32 src_w, src_h, dst_w, dst_h;
282	struct drm_rect src, dst;
283	bool enable = true;
284	bool is_rotation_90_or_270;
285
286	if (!fb || !new_state->crtc || !new_state->visible)
287		return;
288
289	crtc_state = new_state->crtc->state;
290	modifiers_present = !!(fb->flags & DRM_MODE_FB_MODIFIERS);
291
292	if (old_state->fb && !drm_atomic_crtc_needs_modeset(crtc_state) &&
293	    !dcss_plane_needs_setup(new_state, old_state)) {
294		dcss_plane_atomic_set_base(dcss_plane);
295		return;
296	}
297
298	src = plane->state->src;
299	dst = plane->state->dst;
300
301	/*
302	 * The width and height after clipping.
303	 */
304	src_w = drm_rect_width(&src) >> 16;
305	src_h = drm_rect_height(&src) >> 16;
306	dst_w = drm_rect_width(&dst);
307	dst_h = drm_rect_height(&dst);
308
309	if (plane->type == DRM_PLANE_TYPE_OVERLAY &&
310	    modifiers_present && fb->modifier == DRM_FORMAT_MOD_LINEAR)
311		modifiers_present = false;
312
313	dcss_dpr_format_set(dcss->dpr, dcss_plane->ch_num,
314			    new_state->fb->format,
315			    modifiers_present ? fb->modifier :
316						DRM_FORMAT_MOD_LINEAR);
317	dcss_dpr_set_res(dcss->dpr, dcss_plane->ch_num, src_w, src_h);
318	dcss_dpr_set_rotation(dcss->dpr, dcss_plane->ch_num,
319			      new_state->rotation);
320
321	dcss_plane_atomic_set_base(dcss_plane);
322
323	is_rotation_90_or_270 = new_state->rotation & (DRM_MODE_ROTATE_90 |
324						   DRM_MODE_ROTATE_270);
325
326	dcss_scaler_set_filter(dcss->scaler, dcss_plane->ch_num,
327			       new_state->scaling_filter);
328
329	dcss_scaler_setup(dcss->scaler, dcss_plane->ch_num,
330			  new_state->fb->format,
331			  is_rotation_90_or_270 ? src_h : src_w,
332			  is_rotation_90_or_270 ? src_w : src_h,
333			  dst_w, dst_h,
334			  drm_mode_vrefresh(&crtc_state->mode));
335
336	dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
337			       dst.x1, dst.y1, dst_w, dst_h);
338	dcss_dtg_plane_alpha_set(dcss->dtg, dcss_plane->ch_num,
339				 fb->format, new_state->alpha >> 8);
340
341	if (!dcss_plane->ch_num && (new_state->alpha >> 8) == 0)
342		enable = false;
343
344	dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, enable);
345	dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, enable);
346
347	if (!enable)
348		dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
349				       0, 0, 0, 0);
350
351	dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, enable);
352}
353
354static void dcss_plane_atomic_disable(struct drm_plane *plane,
355				      struct drm_atomic_state *state)
356{
357	struct dcss_plane *dcss_plane = to_dcss_plane(plane);
358	struct dcss_dev *dcss = plane->dev->dev_private;
359
360	dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, false);
361	dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, false);
362	dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num, 0, 0, 0, 0);
363	dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, false);
364}
365
366static const struct drm_plane_helper_funcs dcss_plane_helper_funcs = {
367	.atomic_check = dcss_plane_atomic_check,
368	.atomic_update = dcss_plane_atomic_update,
369	.atomic_disable = dcss_plane_atomic_disable,
370};
371
372struct dcss_plane *dcss_plane_init(struct drm_device *drm,
373				   unsigned int possible_crtcs,
374				   enum drm_plane_type type,
375				   unsigned int zpos)
376{
377	struct dcss_plane *dcss_plane;
378	const u64 *format_modifiers = dcss_video_format_modifiers;
379	int ret;
380
381	if (zpos > 2)
382		return ERR_PTR(-EINVAL);
383
384	dcss_plane = kzalloc(sizeof(*dcss_plane), GFP_KERNEL);
385	if (!dcss_plane) {
386		DRM_ERROR("failed to allocate plane\n");
387		return ERR_PTR(-ENOMEM);
388	}
389
390	if (type == DRM_PLANE_TYPE_PRIMARY)
391		format_modifiers = dcss_graphics_format_modifiers;
392
393	ret = drm_universal_plane_init(drm, &dcss_plane->base, possible_crtcs,
394				       &dcss_plane_funcs, dcss_common_formats,
395				       ARRAY_SIZE(dcss_common_formats),
396				       format_modifiers, type, NULL);
397	if (ret) {
398		DRM_ERROR("failed to initialize plane\n");
399		kfree(dcss_plane);
400		return ERR_PTR(ret);
401	}
402
403	drm_plane_helper_add(&dcss_plane->base, &dcss_plane_helper_funcs);
404
405	ret = drm_plane_create_zpos_immutable_property(&dcss_plane->base, zpos);
406	if (ret)
407		return ERR_PTR(ret);
408
409	drm_plane_create_scaling_filter_property(&dcss_plane->base,
410					BIT(DRM_SCALING_FILTER_DEFAULT) |
411					BIT(DRM_SCALING_FILTER_NEAREST_NEIGHBOR));
412
413	drm_plane_create_rotation_property(&dcss_plane->base,
414					   DRM_MODE_ROTATE_0,
415					   DRM_MODE_ROTATE_0   |
416					   DRM_MODE_ROTATE_90  |
417					   DRM_MODE_ROTATE_180 |
418					   DRM_MODE_ROTATE_270 |
419					   DRM_MODE_REFLECT_X  |
420					   DRM_MODE_REFLECT_Y);
421
422	dcss_plane->ch_num = zpos;
423
424	return dcss_plane;
425}