drivers/gpu/drm/arm/display/komeda/komeda_plane.c

   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_plane_helper.h>
  10 #include <drm/drm_print.h>
  11 #include "komeda_dev.h"
  12 #include "komeda_kms.h"
  13 #include "komeda_framebuffer.h"
  14
  15 static int
  16 komeda_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(st->rotation, caps->supported_rots);
  51         if (!has_bits(dflow->rot, caps->supported_rots)) {
  52                 DRM_DEBUG_ATOMIC("rotation(0x%x) isn't supported by %s.\n",
  53                                  dflow->rot,
  54                                  komeda_get_format_name(caps->fourcc,
  55                                                         fb->modifier));
  56                 return -EINVAL;
  57         }
  58
  59         komeda_complete_data_flow_cfg(kplane->layer, dflow, fb);
  60
  61         return 0;
  62 }
  63
  64 /**
  65  * komeda_plane_atomic_check - build input data flow
  66  * @plane: DRM plane
  67  * @state: the plane state object
  68  *
  69  * RETURNS:
  70  * Zero for success or -errno
  71  */
  72 static int
  73 komeda_plane_atomic_check(struct drm_plane *plane,
  74                           struct drm_plane_state *state)
  75 {
  76         struct komeda_plane *kplane = to_kplane(plane);
  77         struct komeda_plane_state *kplane_st = to_kplane_st(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 (!state->crtc || !state->fb)
  85                 return 0;
  86
  87         crtc_st = drm_atomic_get_crtc_state(state->state, state->crtc);
  88         if (IS_ERR(crtc_st) || !crtc_st->enable) {
  89                 DRM_DEBUG_ATOMIC("Cannot update plane on a disabled CRTC.\n");
  90                 return -EINVAL;
  91         }
  92
  93         /* crtc is inactive, skip the resource assignment */
  94         if (!crtc_st->active)
  95                 return 0;
  96
  97         kcrtc_st = to_kcrtc_st(crtc_st);
  98
  99         err = komeda_plane_init_data_flow(state, kcrtc_st, &dflow);
 100         if (err)
 101                 return err;
 102
 103         if (dflow.en_split)
 104                 err = komeda_build_layer_split_data_flow(layer,
 105                                 kplane_st, kcrtc_st, &dflow);
 106         else
 107                 err = komeda_build_layer_data_flow(layer,
 108                                 kplane_st, kcrtc_st, &dflow);
 109
 110         return err;
 111 }
 112
 113 /* plane doesn't represent a real HW, so there is no HW update for plane.
 114  * komeda handles all the HW update in crtc->atomic_flush
 115  */
 116 static void
 117 komeda_plane_atomic_update(struct drm_plane *plane,
 118                            struct drm_plane_state *old_state)
 119 {
 120 }
 121
 122 static const struct drm_plane_helper_funcs komeda_plane_helper_funcs = {
 123         .atomic_check   = komeda_plane_atomic_check,
 124         .atomic_update  = komeda_plane_atomic_update,
 125 };
 126
 127 static void komeda_plane_destroy(struct drm_plane *plane)
 128 {
 129         drm_plane_cleanup(plane);
 130
 131         kfree(to_kplane(plane));
 132 }
 133
 134 static void komeda_plane_reset(struct drm_plane *plane)
 135 {
 136         struct komeda_plane_state *state;
 137         struct komeda_plane *kplane = to_kplane(plane);
 138
 139         if (plane->state)
 140                 __drm_atomic_helper_plane_destroy_state(plane->state);
 141
 142         kfree(plane->state);
 143         plane->state = NULL;
 144
 145         state = kzalloc(sizeof(*state), GFP_KERNEL);
 146         if (state) {
 147                 state->base.rotation = DRM_MODE_ROTATE_0;
 148                 state->base.pixel_blend_mode = DRM_MODE_BLEND_PREMULTI;
 149                 state->base.alpha = DRM_BLEND_ALPHA_OPAQUE;
 150                 state->base.zpos = kplane->layer->base.id;
 151                 state->base.color_encoding = DRM_COLOR_YCBCR_BT601;
 152                 state->base.color_range = DRM_COLOR_YCBCR_LIMITED_RANGE;
 153                 plane->state = &state->base;
 154                 plane->state->plane = plane;
 155         }
 156 }
 157
 158 static struct drm_plane_state *
 159 komeda_plane_atomic_duplicate_state(struct drm_plane *plane)
 160 {
 161         struct komeda_plane_state *new, *old;
 162
 163         if (WARN_ON(!plane->state))
 164                 return NULL;
 165
 166         new = kzalloc(sizeof(*new), GFP_KERNEL);
 167         if (!new)
 168                 return NULL;
 169
 170         __drm_atomic_helper_plane_duplicate_state(plane, &new->base);
 171
 172         old = to_kplane_st(plane->state);
 173
 174         return &new->base;
 175 }
 176
 177 static void
 178 komeda_plane_atomic_destroy_state(struct drm_plane *plane,
 179                                   struct drm_plane_state *state)
 180 {
 181         __drm_atomic_helper_plane_destroy_state(state);
 182         kfree(to_kplane_st(state));
 183 }
 184
 185 static bool
 186 komeda_plane_format_mod_supported(struct drm_plane *plane,
 187                                   u32 format, u64 modifier)
 188 {
 189         struct komeda_dev *mdev = plane->dev->dev_private;
 190         struct komeda_plane *kplane = to_kplane(plane);
 191         u32 layer_type = kplane->layer->layer_type;
 192
 193         return komeda_format_mod_supported(&mdev->fmt_tbl, layer_type,
 194                                            format, modifier, 0);
 195 }
 196
 197 static const struct drm_plane_funcs komeda_plane_funcs = {
 198         .update_plane           = drm_atomic_helper_update_plane,
 199         .disable_plane          = drm_atomic_helper_disable_plane,
 200         .destroy                = komeda_plane_destroy,
 201         .reset                  = komeda_plane_reset,
 202         .atomic_duplicate_state = komeda_plane_atomic_duplicate_state,
 203         .atomic_destroy_state   = komeda_plane_atomic_destroy_state,
 204         .format_mod_supported   = komeda_plane_format_mod_supported,
 205 };
 206
 207 /* for komeda, which is pipeline can be share between crtcs */
 208 static u32 get_possible_crtcs(struct komeda_kms_dev *kms,
 209                               struct komeda_pipeline *pipe)
 210 {
 211         struct komeda_crtc *crtc;
 212         u32 possible_crtcs = 0;
 213         int i;
 214
 215         for (i = 0; i < kms->n_crtcs; i++) {
 216                 crtc = &kms->crtcs[i];
 217
 218                 if ((pipe == crtc->master) || (pipe == crtc->slave))
 219                         possible_crtcs |= BIT(i);
 220         }
 221
 222         return possible_crtcs;
 223 }
 224
 225 static void
 226 komeda_set_crtc_plane_mask(struct komeda_kms_dev *kms,
 227                            struct komeda_pipeline *pipe,
 228                            struct drm_plane *plane)
 229 {
 230         struct komeda_crtc *kcrtc;
 231         int i;
 232
 233         for (i = 0; i < kms->n_crtcs; i++) {
 234                 kcrtc = &kms->crtcs[i];
 235
 236                 if (pipe == kcrtc->slave)
 237                         kcrtc->slave_planes |= BIT(drm_plane_index(plane));
 238         }
 239 }
 240
 241 /* use Layer0 as primary */
 242 static u32 get_plane_type(struct komeda_kms_dev *kms,
 243                           struct komeda_component *c)
 244 {
 245         bool is_primary = (c->id == KOMEDA_COMPONENT_LAYER0);
 246
 247         return is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
 248 }
 249
 250 static int komeda_plane_add(struct komeda_kms_dev *kms,
 251                             struct komeda_layer *layer)
 252 {
 253         struct komeda_dev *mdev = kms->base.dev_private;
 254         struct komeda_component *c = &layer->base;
 255         struct komeda_plane *kplane;
 256         struct drm_plane *plane;
 257         u32 *formats, n_formats = 0;
 258         int err;
 259
 260         kplane = kzalloc(sizeof(*kplane), GFP_KERNEL);
 261         if (!kplane)
 262                 return -ENOMEM;
 263
 264         plane = &kplane->base;
 265         kplane->layer = layer;
 266
 267         formats = komeda_get_layer_fourcc_list(&mdev->fmt_tbl,
 268                                                layer->layer_type, &n_formats);
 269
 270         err = drm_universal_plane_init(&kms->base, plane,
 271                         get_possible_crtcs(kms, c->pipeline),
 272                         &komeda_plane_funcs,
 273                         formats, n_formats, komeda_supported_modifiers,
 274                         get_plane_type(kms, c),
 275                         "%s", c->name);
 276
 277         komeda_put_fourcc_list(formats);
 278
 279         if (err)
 280                 goto cleanup;
 281
 282         drm_plane_helper_add(plane, &komeda_plane_helper_funcs);
 283
 284         err = drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
 285                                                  layer->supported_rots);
 286         if (err)
 287                 goto cleanup;
 288
 289         err = drm_plane_create_alpha_property(plane);
 290         if (err)
 291                 goto cleanup;
 292
 293         err = drm_plane_create_blend_mode_property(plane,
 294                         BIT(DRM_MODE_BLEND_PIXEL_NONE) |
 295                         BIT(DRM_MODE_BLEND_PREMULTI)   |
 296                         BIT(DRM_MODE_BLEND_COVERAGE));
 297         if (err)
 298                 goto cleanup;
 299
 300         err = drm_plane_create_color_properties(plane,
 301                         BIT(DRM_COLOR_YCBCR_BT601) |
 302                         BIT(DRM_COLOR_YCBCR_BT709) |
 303                         BIT(DRM_COLOR_YCBCR_BT2020),
 304                         BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
 305                         BIT(DRM_COLOR_YCBCR_FULL_RANGE),
 306                         DRM_COLOR_YCBCR_BT601,
 307                         DRM_COLOR_YCBCR_LIMITED_RANGE);
 308         if (err)
 309                 goto cleanup;
 310
 311         err = drm_plane_create_zpos_property(plane, layer->base.id, 0, 8);
 312         if (err)
 313                 goto cleanup;
 314
 315         komeda_set_crtc_plane_mask(kms, c->pipeline, plane);
 316
 317         return 0;
 318 cleanup:
 319         komeda_plane_destroy(plane);
 320         return err;
 321 }
 322
 323 int komeda_kms_add_planes(struct komeda_kms_dev *kms, struct komeda_dev *mdev)
 324 {
 325         struct komeda_pipeline *pipe;
 326         int i, j, err;
 327
 328         for (i = 0; i < mdev->n_pipelines; i++) {
 329                 pipe = mdev->pipelines[i];
 330
 331                 for (j = 0; j < pipe->n_layers; j++) {
 332                         err = komeda_plane_add(kms, pipe->layers[j]);
 333                         if (err)
 334                                 return err;
 335                 }
 336         }
 337
 338         return 0;
 339 }