1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
4 * Author: James.Qian.Wang <james.qian.wang@arm.com>
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_print.h>
11#include "komeda_dev.h"
12#include "komeda_kms.h"
13#include "komeda_framebuffer.h"
14
15static int
16komeda_plane_init_data_flow(struct drm_plane_state *st,
17 struct komeda_crtc_state *kcrtc_st,
18 struct komeda_data_flow_cfg *dflow)
19{
20 struct komeda_plane *kplane = to_kplane(st->plane);
21 struct drm_framebuffer *fb = st->fb;
22 const struct komeda_format_caps *caps = to_kfb(fb)->format_caps;
23 struct komeda_pipeline *pipe = kplane->layer->base.pipeline;
24
25 memset(dflow, 0, sizeof(*dflow));
26
27 dflow->blending_zorder = st->normalized_zpos;
28 if (pipe == to_kcrtc(st->crtc)->master)
29 dflow->blending_zorder -= kcrtc_st->max_slave_zorder;
30 if (dflow->blending_zorder < 0) {
31 DRM_DEBUG_ATOMIC("%s zorder:%d < max_slave_zorder: %d.\n",
32 st->plane->name, st->normalized_zpos,
33 kcrtc_st->max_slave_zorder);
34 return -EINVAL;
35 }
36
37 dflow->pixel_blend_mode = st->pixel_blend_mode;
38 dflow->layer_alpha = st->alpha >> 8;
39
40 dflow->out_x = st->crtc_x;
41 dflow->out_y = st->crtc_y;
42 dflow->out_w = st->crtc_w;
43 dflow->out_h = st->crtc_h;
44
45 dflow->in_x = st->src_x >> 16;
46 dflow->in_y = st->src_y >> 16;
47 dflow->in_w = st->src_w >> 16;
48 dflow->in_h = st->src_h >> 16;
49
50 dflow->rot = drm_rotation_simplify(rotation: st->rotation, supported_rotations: caps->supported_rots);
51 if (!has_bits(dflow->rot, caps->supported_rots)) {
52 DRM_DEBUG_ATOMIC("rotation(0x%x) isn't supported by %p4cc with modifier: 0x%llx.\n",
53 dflow->rot, &caps->fourcc, fb->modifier);
54 return -EINVAL;
55 }
56
57 komeda_complete_data_flow_cfg(layer: kplane->layer, dflow, fb);
58
59 return 0;
60}
61
62/**
63 * komeda_plane_atomic_check - build input data flow
64 * @plane: DRM plane
65 * @state: the plane state object
66 *
67 * RETURNS:
68 * Zero for success or -errno
69 */
70static int
71komeda_plane_atomic_check(struct drm_plane *plane,
72 struct drm_atomic_state *state)
73{
74 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
75 plane);
76 struct komeda_plane *kplane = to_kplane(plane);
77 struct komeda_plane_state *kplane_st = to_kplane_st(new_plane_state);
78 struct komeda_layer *layer = kplane->layer;
79 struct drm_crtc_state *crtc_st;
80 struct komeda_crtc_state *kcrtc_st;
81 struct komeda_data_flow_cfg dflow;
82 int err;
83
84 if (!new_plane_state->crtc || !new_plane_state->fb)
85 return 0;
86
87 crtc_st = drm_atomic_get_crtc_state(state,
88 crtc: new_plane_state->crtc);
89 if (IS_ERR(ptr: crtc_st) || !crtc_st->enable) {
90 DRM_DEBUG_ATOMIC("Cannot update plane on a disabled CRTC.\n");
91 return -EINVAL;
92 }
93
94 /* crtc is inactive, skip the resource assignment */
95 if (!crtc_st->active)
96 return 0;
97
98 kcrtc_st = to_kcrtc_st(crtc_st);
99
100 err = komeda_plane_init_data_flow(st: new_plane_state, kcrtc_st, dflow: &dflow);
101 if (err)
102 return err;
103
104 if (dflow.en_split)
105 err = komeda_build_layer_split_data_flow(left: layer,
106 kplane_st, kcrtc_st, dflow: &dflow);
107 else
108 err = komeda_build_layer_data_flow(layer,
109 kplane_st, kcrtc_st, dflow: &dflow);
110
111 return err;
112}
113
114/* plane doesn't represent a real HW, so there is no HW update for plane.
115 * komeda handles all the HW update in crtc->atomic_flush
116 */
117static void
118komeda_plane_atomic_update(struct drm_plane *plane,
119 struct drm_atomic_state *state)
120{
121}
122
123static const struct drm_plane_helper_funcs komeda_plane_helper_funcs = {
124 .atomic_check = komeda_plane_atomic_check,
125 .atomic_update = komeda_plane_atomic_update,
126};
127
128static void komeda_plane_destroy(struct drm_plane *plane)
129{
130 drm_plane_cleanup(plane);
131
132 kfree(to_kplane(plane));
133}
134
135static void komeda_plane_reset(struct drm_plane *plane)
136{
137 struct komeda_plane_state *state;
138
139 if (plane->state)
140 __drm_atomic_helper_plane_destroy_state(state: plane->state);
141
142 kfree(objp: plane->state);
143 plane->state = NULL;
144
145 state = kzalloc(sizeof(*state), GFP_KERNEL);
146 if (state)
147 __drm_atomic_helper_plane_reset(plane, state: &state->base);
148}
149
150static struct drm_plane_state *
151komeda_plane_atomic_duplicate_state(struct drm_plane *plane)
152{
153 struct komeda_plane_state *new;
154
155 if (WARN_ON(!plane->state))
156 return NULL;
157
158 new = kzalloc(sizeof(*new), GFP_KERNEL);
159 if (!new)
160 return NULL;
161
162 __drm_atomic_helper_plane_duplicate_state(plane, state: &new->base);
163
164 return &new->base;
165}
166
167static void
168komeda_plane_atomic_destroy_state(struct drm_plane *plane,
169 struct drm_plane_state *state)
170{
171 __drm_atomic_helper_plane_destroy_state(state);
172 kfree(to_kplane_st(state));
173}
174
175static bool
176komeda_plane_format_mod_supported(struct drm_plane *plane,
177 u32 format, u64 modifier)
178{
179 struct komeda_dev *mdev = plane->dev->dev_private;
180 struct komeda_plane *kplane = to_kplane(plane);
181 u32 layer_type = kplane->layer->layer_type;
182
183 return komeda_format_mod_supported(table: &mdev->fmt_tbl, layer_type,
184 fourcc: format, modifier, rot: 0);
185}
186
187static const struct drm_plane_funcs komeda_plane_funcs = {
188 .update_plane = drm_atomic_helper_update_plane,
189 .disable_plane = drm_atomic_helper_disable_plane,
190 .destroy = komeda_plane_destroy,
191 .reset = komeda_plane_reset,
192 .atomic_duplicate_state = komeda_plane_atomic_duplicate_state,
193 .atomic_destroy_state = komeda_plane_atomic_destroy_state,
194 .format_mod_supported = komeda_plane_format_mod_supported,
195};
196
197/* for komeda, which is pipeline can be share between crtcs */
198static u32 get_possible_crtcs(struct komeda_kms_dev *kms,
199 struct komeda_pipeline *pipe)
200{
201 struct komeda_crtc *crtc;
202 u32 possible_crtcs = 0;
203 int i;
204
205 for (i = 0; i < kms->n_crtcs; i++) {
206 crtc = &kms->crtcs[i];
207
208 if ((pipe == crtc->master) || (pipe == crtc->slave))
209 possible_crtcs |= BIT(i);
210 }
211
212 return possible_crtcs;
213}
214
215static void
216komeda_set_crtc_plane_mask(struct komeda_kms_dev *kms,
217 struct komeda_pipeline *pipe,
218 struct drm_plane *plane)
219{
220 struct komeda_crtc *kcrtc;
221 int i;
222
223 for (i = 0; i < kms->n_crtcs; i++) {
224 kcrtc = &kms->crtcs[i];
225
226 if (pipe == kcrtc->slave)
227 kcrtc->slave_planes |= BIT(drm_plane_index(plane));
228 }
229}
230
231/* use Layer0 as primary */
232static u32 get_plane_type(struct komeda_kms_dev *kms,
233 struct komeda_component *c)
234{
235 bool is_primary = (c->id == KOMEDA_COMPONENT_LAYER0);
236
237 return is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
238}
239
240static int komeda_plane_add(struct komeda_kms_dev *kms,
241 struct komeda_layer *layer)
242{
243 struct komeda_dev *mdev = kms->base.dev_private;
244 struct komeda_component *c = &layer->base;
245 struct komeda_plane *kplane;
246 struct drm_plane *plane;
247 u32 *formats, n_formats = 0;
248 int err;
249
250 kplane = kzalloc(sizeof(*kplane), GFP_KERNEL);
251 if (!kplane)
252 return -ENOMEM;
253
254 plane = &kplane->base;
255 kplane->layer = layer;
256
257 formats = komeda_get_layer_fourcc_list(table: &mdev->fmt_tbl,
258 layer_type: layer->layer_type, n_fmts: &n_formats);
259 if (!formats) {
260 kfree(objp: kplane);
261 return -ENOMEM;
262 }
263
264 err = drm_universal_plane_init(dev: &kms->base, plane,
265 possible_crtcs: get_possible_crtcs(kms, pipe: c->pipeline),
266 funcs: &komeda_plane_funcs,
267 formats, format_count: n_formats, format_modifiers: komeda_supported_modifiers,
268 type: get_plane_type(kms, c),
269 name: "%s", c->name);
270
271 komeda_put_fourcc_list(fourcc_list: formats);
272
273 if (err) {
274 kfree(objp: kplane);
275 return err;
276 }
277
278 drm_plane_helper_add(plane, funcs: &komeda_plane_helper_funcs);
279
280 err = drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
281 supported_rotations: layer->supported_rots);
282 if (err)
283 goto cleanup;
284
285 err = drm_plane_create_alpha_property(plane);
286 if (err)
287 goto cleanup;
288
289 err = drm_plane_create_blend_mode_property(plane,
290 BIT(DRM_MODE_BLEND_PIXEL_NONE) |
291 BIT(DRM_MODE_BLEND_PREMULTI) |
292 BIT(DRM_MODE_BLEND_COVERAGE));
293 if (err)
294 goto cleanup;
295
296 err = drm_plane_create_color_properties(plane,
297 BIT(DRM_COLOR_YCBCR_BT601) |
298 BIT(DRM_COLOR_YCBCR_BT709) |
299 BIT(DRM_COLOR_YCBCR_BT2020),
300 BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
301 BIT(DRM_COLOR_YCBCR_FULL_RANGE),
302 default_encoding: DRM_COLOR_YCBCR_BT601,
303 default_range: DRM_COLOR_YCBCR_LIMITED_RANGE);
304 if (err)
305 goto cleanup;
306
307 err = drm_plane_create_zpos_property(plane, zpos: layer->base.id, min: 0, max: 8);
308 if (err)
309 goto cleanup;
310
311 komeda_set_crtc_plane_mask(kms, pipe: c->pipeline, plane);
312
313 return 0;
314cleanup:
315 komeda_plane_destroy(plane);
316 return err;
317}
318
319int komeda_kms_add_planes(struct komeda_kms_dev *kms, struct komeda_dev *mdev)
320{
321 struct komeda_pipeline *pipe;
322 int i, j, err;
323
324 for (i = 0; i < mdev->n_pipelines; i++) {
325 pipe = mdev->pipelines[i];
326
327 for (j = 0; j < pipe->n_layers; j++) {
328 err = komeda_plane_add(kms, layer: pipe->layers[j]);
329 if (err)
330 return err;
331 }
332 }
333
334 return 0;
335}
336

source code of linux/drivers/gpu/drm/arm/display/komeda/komeda_plane.c