dc-plane.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Copyright 2024 NXP
  4 */
  5
  6#include <linux/container_of.h>
  7
  8#include <drm/drm_atomic.h>
  9#include <drm/drm_atomic_helper.h>
 10#include <drm/drm_atomic_state_helper.h>
 11#include <drm/drm_crtc.h>
 12#include <drm/drm_drv.h>
 13#include <drm/drm_fb_dma_helper.h>
 14#include <drm/drm_fourcc.h>
 15#include <drm/drm_framebuffer.h>
 16#include <drm/drm_gem_atomic_helper.h>
 17#include <drm/drm_plane_helper.h>
 18#include <drm/drm_print.h>
 19
 20#include "dc-drv.h"
 21#include "dc-fu.h"
 22#include "dc-kms.h"
 23
 24#define DC_PLANE_MAX_PITCH	0x10000
 25#define DC_PLANE_MAX_PIX_CNT	8192
 26
 27#define dc_plane_dbg(plane, fmt, ...)					\
 28do {									\
 29	struct drm_plane *_plane = (plane);				\
 30	drm_dbg_kms(_plane->dev, "[PLANE:%d:%s] " fmt,			\
 31		    _plane->base.id, _plane->name, ##__VA_ARGS__);	\
 32} while (0)
 33
 34static const uint32_t dc_plane_formats[] = {
 35	DRM_FORMAT_XRGB8888,
 36};
 37
 38static const struct drm_plane_funcs dc_plane_funcs = {
 39	.update_plane		= drm_atomic_helper_update_plane,
 40	.disable_plane		= drm_atomic_helper_disable_plane,
 41	.destroy		= drm_plane_cleanup,
 42	.reset			= drm_atomic_helper_plane_reset,
 43	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
 44	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
 45};
 46
 47static inline struct dc_plane *to_dc_plane(struct drm_plane *plane)
 48{
 49	return container_of(plane, struct dc_plane, base);
 50}
 51
 52static int dc_plane_check_max_source_resolution(struct drm_plane_state *state)
 53{
 54	int src_h = drm_rect_height(&state->src) >> 16;
 55	int src_w = drm_rect_width(&state->src) >> 16;
 56
 57	if (src_w > DC_PLANE_MAX_PIX_CNT || src_h > DC_PLANE_MAX_PIX_CNT) {
 58		dc_plane_dbg(state->plane, "invalid source resolution\n");
 59		return -EINVAL;
 60	}
 61
 62	return 0;
 63}
 64
 65static int dc_plane_check_fb(struct drm_plane_state *state)
 66{
 67	struct drm_framebuffer *fb = state->fb;
 68	dma_addr_t baseaddr = drm_fb_dma_get_gem_addr(fb, state, 0);
 69
 70	/* base address alignment */
 71	if (baseaddr & 0x3) {
 72		dc_plane_dbg(state->plane, "fb bad baddr alignment\n");
 73		return -EINVAL;
 74	}
 75
 76	/* pitches[0] range */
 77	if (fb->pitches[0] > DC_PLANE_MAX_PITCH) {
 78		dc_plane_dbg(state->plane, "fb pitches[0] is out of range\n");
 79		return -EINVAL;
 80	}
 81
 82	/* pitches[0] alignment */
 83	if (fb->pitches[0] & 0x3) {
 84		dc_plane_dbg(state->plane, "fb bad pitches[0] alignment\n");
 85		return -EINVAL;
 86	}
 87
 88	return 0;
 89}
 90
 91static int
 92dc_plane_atomic_check(struct drm_plane *plane, struct drm_atomic_state *state)
 93{
 94	struct drm_plane_state *plane_state =
 95				drm_atomic_get_new_plane_state(state, plane);
 96	struct drm_crtc_state *crtc_state;
 97	int ret;
 98
 99	/* ok to disable */
100	if (!plane_state->fb)
101		return 0;
102
103	if (!plane_state->crtc) {
104		dc_plane_dbg(plane, "no CRTC in plane state\n");
105		return -EINVAL;
106	}
107
108	crtc_state =
109		drm_atomic_get_new_crtc_state(state, plane_state->crtc);
110	if (WARN_ON(!crtc_state))
111		return -EINVAL;
112
113	ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state,
114						  DRM_PLANE_NO_SCALING,
115						  DRM_PLANE_NO_SCALING,
116						  true, false);
117	if (ret) {
118		dc_plane_dbg(plane, "failed to check plane state: %d\n", ret);
119		return ret;
120	}
121
122	ret = dc_plane_check_max_source_resolution(plane_state);
123	if (ret)
124		return ret;
125
126	return dc_plane_check_fb(plane_state);
127}
128
129static void
130dc_plane_atomic_update(struct drm_plane *plane, struct drm_atomic_state *state)
131{
132	struct drm_plane_state *new_state =
133				drm_atomic_get_new_plane_state(state, plane);
134	struct dc_plane *dplane = to_dc_plane(plane);
135	struct drm_framebuffer *fb = new_state->fb;
136	const struct dc_fu_ops *fu_ops;
137	struct dc_lb *lb = dplane->lb;
138	struct dc_fu *fu = dplane->fu;
139	dma_addr_t baseaddr;
140	int src_w, src_h;
141	int idx;
142
143	if (!drm_dev_enter(plane->dev, &idx))
144		return;
145
146	src_w = drm_rect_width(&new_state->src) >> 16;
147	src_h = drm_rect_height(&new_state->src) >> 16;
148
149	baseaddr = drm_fb_dma_get_gem_addr(fb, new_state, 0);
150
151	fu_ops = dc_fu_get_ops(dplane->fu);
152
153	fu_ops->set_layerblend(fu, lb);
154	fu_ops->set_burstlength(fu, baseaddr);
155	fu_ops->set_src_stride(fu, DC_FETCHUNIT_FRAC0, fb->pitches[0]);
156	fu_ops->set_src_buf_dimensions(fu, DC_FETCHUNIT_FRAC0, src_w, src_h);
157	fu_ops->set_fmt(fu, DC_FETCHUNIT_FRAC0, fb->format);
158	fu_ops->set_framedimensions(fu, src_w, src_h);
159	fu_ops->set_baseaddress(fu, DC_FETCHUNIT_FRAC0, baseaddr);
160	fu_ops->enable_src_buf(fu, DC_FETCHUNIT_FRAC0);
161
162	dc_plane_dbg(plane, "uses %s\n", fu_ops->get_name(fu));
163
164	dc_lb_pec_dynamic_prim_sel(lb, dc_cf_get_link_id(dplane->cf));
165	dc_lb_pec_dynamic_sec_sel(lb, fu_ops->get_link_id(fu));
166	dc_lb_mode(lb, LB_BLEND);
167	dc_lb_position(lb, new_state->dst.x1, new_state->dst.y1);
168	dc_lb_pec_clken(lb, CLKEN_AUTOMATIC);
169
170	dc_plane_dbg(plane, "uses LayerBlend%d\n", dc_lb_get_id(lb));
171
172	/* set ExtDst's source to LayerBlend */
173	dc_ed_pec_src_sel(dplane->ed, dc_lb_get_link_id(lb));
174
175	drm_dev_exit(idx);
176}
177
178static void dc_plane_atomic_disable(struct drm_plane *plane,
179				    struct drm_atomic_state *state)
180{
181	struct dc_plane *dplane = to_dc_plane(plane);
182	const struct dc_fu_ops *fu_ops;
183	int idx;
184
185	if (!drm_dev_enter(plane->dev, &idx))
186		return;
187
188	/* disable fetchunit in shadow */
189	fu_ops = dc_fu_get_ops(dplane->fu);
190	fu_ops->disable_src_buf(dplane->fu, DC_FETCHUNIT_FRAC0);
191
192	/* set ExtDst's source to ConstFrame */
193	dc_ed_pec_src_sel(dplane->ed, dc_cf_get_link_id(dplane->cf));
194
195	drm_dev_exit(idx);
196}
197
198static const struct drm_plane_helper_funcs dc_plane_helper_funcs = {
199	.atomic_check = dc_plane_atomic_check,
200	.atomic_update = dc_plane_atomic_update,
201	.atomic_disable = dc_plane_atomic_disable,
202};
203
204int dc_plane_init(struct dc_drm_device *dc_drm, struct dc_plane *dc_plane)
205{
206	struct drm_plane *plane = &dc_plane->base;
207	int ret;
208
209	ret = drm_universal_plane_init(&dc_drm->base, plane, 0, &dc_plane_funcs,
210				       dc_plane_formats,
211				       ARRAY_SIZE(dc_plane_formats),
212				       NULL, DRM_PLANE_TYPE_PRIMARY, NULL);
213	if (ret)
214		return ret;
215
216	drm_plane_helper_add(plane, &dc_plane_helper_funcs);
217
218	dc_plane->fu = dc_drm->pe->fu_disp[plane->index];
219	dc_plane->cf = dc_drm->pe->cf_cont[plane->index];
220	dc_plane->lb = dc_drm->pe->lb[plane->index];
221	dc_plane->ed = dc_drm->pe->ed_cont[plane->index];
222
223	return 0;
224}