display/komeda/komeda_plane.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
0004  * Author: James.Qian.Wang <james.qian.wang@arm.com>
0005  *
0006  */
0007 #include <drm/drm_atomic.h>
0008 #include <drm/drm_atomic_helper.h>
0009 #include <drm/drm_blend.h>
0010 #include <drm/drm_plane_helper.h>
0011 #include <drm/drm_print.h>
0012 #include "komeda_dev.h"
0013 #include "komeda_kms.h"
0014 #include "komeda_framebuffer.h"
0015
0016 static int
0017 komeda_plane_init_data_flow(struct drm_plane_state *st,
0018                 struct komeda_crtc_state *kcrtc_st,
0019                 struct komeda_data_flow_cfg *dflow)
0020 {
0021     struct komeda_plane *kplane = to_kplane(st->plane);
0022     struct drm_framebuffer *fb = st->fb;
0023     const struct komeda_format_caps *caps = to_kfb(fb)->format_caps;
0024     struct komeda_pipeline *pipe = kplane->layer->base.pipeline;
0025
0026     memset(dflow, 0, sizeof(*dflow));
0027
0028     dflow->blending_zorder = st->normalized_zpos;
0029     if (pipe == to_kcrtc(st->crtc)->master)
0030         dflow->blending_zorder -= kcrtc_st->max_slave_zorder;
0031     if (dflow->blending_zorder < 0) {
0032         DRM_DEBUG_ATOMIC("%s zorder:%d < max_slave_zorder: %d.\n",
0033                  st->plane->name, st->normalized_zpos,
0034                  kcrtc_st->max_slave_zorder);
0035         return -EINVAL;
0036     }
0037
0038     dflow->pixel_blend_mode = st->pixel_blend_mode;
0039     dflow->layer_alpha = st->alpha >> 8;
0040
0041     dflow->out_x = st->crtc_x;
0042     dflow->out_y = st->crtc_y;
0043     dflow->out_w = st->crtc_w;
0044     dflow->out_h = st->crtc_h;
0045
0046     dflow->in_x = st->src_x >> 16;
0047     dflow->in_y = st->src_y >> 16;
0048     dflow->in_w = st->src_w >> 16;
0049     dflow->in_h = st->src_h >> 16;
0050
0051     dflow->rot = drm_rotation_simplify(st->rotation, caps->supported_rots);
0052     if (!has_bits(dflow->rot, caps->supported_rots)) {
0053         DRM_DEBUG_ATOMIC("rotation(0x%x) isn't supported by %p4cc with modifier: 0x%llx.\n",
0054                  dflow->rot, &caps->fourcc, fb->modifier);
0055         return -EINVAL;
0056     }
0057
0058     komeda_complete_data_flow_cfg(kplane->layer, dflow, fb);
0059
0060     return 0;
0061 }
0062
0063 /**
0064  * komeda_plane_atomic_check - build input data flow
0065  * @plane: DRM plane
0066  * @state: the plane state object
0067  *
0068  * RETURNS:
0069  * Zero for success or -errno
0070  */
0071 static int
0072 komeda_plane_atomic_check(struct drm_plane *plane,
0073               struct drm_atomic_state *state)
0074 {
0075     struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
0076                                          plane);
0077     struct komeda_plane *kplane = to_kplane(plane);
0078     struct komeda_plane_state *kplane_st = to_kplane_st(new_plane_state);
0079     struct komeda_layer *layer = kplane->layer;
0080     struct drm_crtc_state *crtc_st;
0081     struct komeda_crtc_state *kcrtc_st;
0082     struct komeda_data_flow_cfg dflow;
0083     int err;
0084
0085     if (!new_plane_state->crtc || !new_plane_state->fb)
0086         return 0;
0087
0088     crtc_st = drm_atomic_get_crtc_state(state,
0089                         new_plane_state->crtc);
0090     if (IS_ERR(crtc_st) || !crtc_st->enable) {
0091         DRM_DEBUG_ATOMIC("Cannot update plane on a disabled CRTC.\n");
0092         return -EINVAL;
0093     }
0094
0095     /* crtc is inactive, skip the resource assignment */
0096     if (!crtc_st->active)
0097         return 0;
0098
0099     kcrtc_st = to_kcrtc_st(crtc_st);
0100
0101     err = komeda_plane_init_data_flow(new_plane_state, kcrtc_st, &dflow);
0102     if (err)
0103         return err;
0104
0105     if (dflow.en_split)
0106         err = komeda_build_layer_split_data_flow(layer,
0107                 kplane_st, kcrtc_st, &dflow);
0108     else
0109         err = komeda_build_layer_data_flow(layer,
0110                 kplane_st, kcrtc_st, &dflow);
0111
0112     return err;
0113 }
0114
0115 /* plane doesn't represent a real HW, so there is no HW update for plane.
0116  * komeda handles all the HW update in crtc->atomic_flush
0117  */
0118 static void
0119 komeda_plane_atomic_update(struct drm_plane *plane,
0120                struct drm_atomic_state *state)
0121 {
0122 }
0123
0124 static const struct drm_plane_helper_funcs komeda_plane_helper_funcs = {
0125     .atomic_check   = komeda_plane_atomic_check,
0126     .atomic_update  = komeda_plane_atomic_update,
0127 };
0128
0129 static void komeda_plane_destroy(struct drm_plane *plane)
0130 {
0131     drm_plane_cleanup(plane);
0132
0133     kfree(to_kplane(plane));
0134 }
0135
0136 static void komeda_plane_reset(struct drm_plane *plane)
0137 {
0138     struct komeda_plane_state *state;
0139
0140     if (plane->state)
0141         __drm_atomic_helper_plane_destroy_state(plane->state);
0142
0143     kfree(plane->state);
0144     plane->state = NULL;
0145
0146     state = kzalloc(sizeof(*state), GFP_KERNEL);
0147     if (state)
0148         __drm_atomic_helper_plane_reset(plane, &state->base);
0149 }
0150
0151 static struct drm_plane_state *
0152 komeda_plane_atomic_duplicate_state(struct drm_plane *plane)
0153 {
0154     struct komeda_plane_state *new;
0155
0156     if (WARN_ON(!plane->state))
0157         return NULL;
0158
0159     new = kzalloc(sizeof(*new), GFP_KERNEL);
0160     if (!new)
0161         return NULL;
0162
0163     __drm_atomic_helper_plane_duplicate_state(plane, &new->base);
0164
0165     return &new->base;
0166 }
0167
0168 static void
0169 komeda_plane_atomic_destroy_state(struct drm_plane *plane,
0170                   struct drm_plane_state *state)
0171 {
0172     __drm_atomic_helper_plane_destroy_state(state);
0173     kfree(to_kplane_st(state));
0174 }
0175
0176 static bool
0177 komeda_plane_format_mod_supported(struct drm_plane *plane,
0178                   u32 format, u64 modifier)
0179 {
0180     struct komeda_dev *mdev = plane->dev->dev_private;
0181     struct komeda_plane *kplane = to_kplane(plane);
0182     u32 layer_type = kplane->layer->layer_type;
0183
0184     return komeda_format_mod_supported(&mdev->fmt_tbl, layer_type,
0185                        format, modifier, 0);
0186 }
0187
0188 static const struct drm_plane_funcs komeda_plane_funcs = {
0189     .update_plane       = drm_atomic_helper_update_plane,
0190     .disable_plane      = drm_atomic_helper_disable_plane,
0191     .destroy        = komeda_plane_destroy,
0192     .reset          = komeda_plane_reset,
0193     .atomic_duplicate_state = komeda_plane_atomic_duplicate_state,
0194     .atomic_destroy_state   = komeda_plane_atomic_destroy_state,
0195     .format_mod_supported   = komeda_plane_format_mod_supported,
0196 };
0197
0198 /* for komeda, which is pipeline can be share between crtcs */
0199 static u32 get_possible_crtcs(struct komeda_kms_dev *kms,
0200                   struct komeda_pipeline *pipe)
0201 {
0202     struct komeda_crtc *crtc;
0203     u32 possible_crtcs = 0;
0204     int i;
0205
0206     for (i = 0; i < kms->n_crtcs; i++) {
0207         crtc = &kms->crtcs[i];
0208
0209         if ((pipe == crtc->master) || (pipe == crtc->slave))
0210             possible_crtcs |= BIT(i);
0211     }
0212
0213     return possible_crtcs;
0214 }
0215
0216 static void
0217 komeda_set_crtc_plane_mask(struct komeda_kms_dev *kms,
0218                struct komeda_pipeline *pipe,
0219                struct drm_plane *plane)
0220 {
0221     struct komeda_crtc *kcrtc;
0222     int i;
0223
0224     for (i = 0; i < kms->n_crtcs; i++) {
0225         kcrtc = &kms->crtcs[i];
0226
0227         if (pipe == kcrtc->slave)
0228             kcrtc->slave_planes |= BIT(drm_plane_index(plane));
0229     }
0230 }
0231
0232 /* use Layer0 as primary */
0233 static u32 get_plane_type(struct komeda_kms_dev *kms,
0234               struct komeda_component *c)
0235 {
0236     bool is_primary = (c->id == KOMEDA_COMPONENT_LAYER0);
0237
0238     return is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
0239 }
0240
0241 static int komeda_plane_add(struct komeda_kms_dev *kms,
0242                 struct komeda_layer *layer)
0243 {
0244     struct komeda_dev *mdev = kms->base.dev_private;
0245     struct komeda_component *c = &layer->base;
0246     struct komeda_plane *kplane;
0247     struct drm_plane *plane;
0248     u32 *formats, n_formats = 0;
0249     int err;
0250
0251     kplane = kzalloc(sizeof(*kplane), GFP_KERNEL);
0252     if (!kplane)
0253         return -ENOMEM;
0254
0255     plane = &kplane->base;
0256     kplane->layer = layer;
0257
0258     formats = komeda_get_layer_fourcc_list(&mdev->fmt_tbl,
0259                            layer->layer_type, &n_formats);
0260     if (!formats) {
0261         kfree(kplane);
0262         return -ENOMEM;
0263     }
0264
0265     err = drm_universal_plane_init(&kms->base, plane,
0266             get_possible_crtcs(kms, c->pipeline),
0267             &komeda_plane_funcs,
0268             formats, n_formats, komeda_supported_modifiers,
0269             get_plane_type(kms, c),
0270             "%s", c->name);
0271
0272     komeda_put_fourcc_list(formats);
0273
0274     if (err) {
0275         kfree(kplane);
0276         return err;
0277     }
0278
0279     drm_plane_helper_add(plane, &komeda_plane_helper_funcs);
0280
0281     err = drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
0282                          layer->supported_rots);
0283     if (err)
0284         goto cleanup;
0285
0286     err = drm_plane_create_alpha_property(plane);
0287     if (err)
0288         goto cleanup;
0289
0290     err = drm_plane_create_blend_mode_property(plane,
0291             BIT(DRM_MODE_BLEND_PIXEL_NONE) |
0292             BIT(DRM_MODE_BLEND_PREMULTI)   |
0293             BIT(DRM_MODE_BLEND_COVERAGE));
0294     if (err)
0295         goto cleanup;
0296
0297     err = drm_plane_create_color_properties(plane,
0298             BIT(DRM_COLOR_YCBCR_BT601) |
0299             BIT(DRM_COLOR_YCBCR_BT709) |
0300             BIT(DRM_COLOR_YCBCR_BT2020),
0301             BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
0302             BIT(DRM_COLOR_YCBCR_FULL_RANGE),
0303             DRM_COLOR_YCBCR_BT601,
0304             DRM_COLOR_YCBCR_LIMITED_RANGE);
0305     if (err)
0306         goto cleanup;
0307
0308     err = drm_plane_create_zpos_property(plane, layer->base.id, 0, 8);
0309     if (err)
0310         goto cleanup;
0311
0312     komeda_set_crtc_plane_mask(kms, c->pipeline, plane);
0313
0314     return 0;
0315 cleanup:
0316     komeda_plane_destroy(plane);
0317     return err;
0318 }
0319
0320 int komeda_kms_add_planes(struct komeda_kms_dev *kms, struct komeda_dev *mdev)
0321 {
0322     struct komeda_pipeline *pipe;
0323     int i, j, err;
0324
0325     for (i = 0; i < mdev->n_pipelines; i++) {
0326         pipe = mdev->pipelines[i];
0327
0328         for (j = 0; j < pipe->n_layers; j++) {
0329             err = komeda_plane_add(kms, pipe->layers[j]);
0330             if (err)
0331                 return err;
0332         }
0333     }
0334
0335     return 0;
0336 }