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 %p4cc with modifier: 0x%llx.\n",
  53                                  dflow->rot, &caps->fourcc, fb->modifier);
  54                 return -EINVAL;
  55         }
  56
  57         komeda_complete_data_flow_cfg(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  */
  70 static int
  71 komeda_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                                             new_plane_state->crtc);
  89         if (IS_ERR(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(new_plane_state, kcrtc_st, &dflow);
 101         if (err)
 102                 return err;
 103
 104         if (dflow.en_split)
 105                 err = komeda_build_layer_split_data_flow(layer,
 106                                 kplane_st, kcrtc_st, &dflow);
 107         else
 108                 err = komeda_build_layer_data_flow(layer,
 109                                 kplane_st, kcrtc_st, &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  */
 117 static void
 118 komeda_plane_atomic_update(struct drm_plane *plane,
 119                            struct drm_atomic_state *state)
 120 {
 121 }
 122
 123 static 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
 128 static void komeda_plane_destroy(struct drm_plane *plane)
 129 {
 130         drm_plane_cleanup(plane);
 131
 132         kfree(to_kplane(plane));
 133 }
 134
 135 static void komeda_plane_reset(struct drm_plane *plane)
 136 {
 137         struct komeda_plane_state *state;
 138         struct komeda_plane *kplane = to_kplane(plane);
 139
 140         if (plane->state)
 141                 __drm_atomic_helper_plane_destroy_state(plane->state);
 142
 143         kfree(plane->state);
 144         plane->state = NULL;
 145
 146         state = kzalloc(sizeof(*state), GFP_KERNEL);
 147         if (state) {
 148                 __drm_atomic_helper_plane_reset(plane, &state->base);
 149                 state->base.zpos = kplane->layer->base.id;
 150                 state->base.color_encoding = DRM_COLOR_YCBCR_BT601;
 151                 state->base.color_range = DRM_COLOR_YCBCR_LIMITED_RANGE;
 152         }
 153 }
 154
 155 static struct drm_plane_state *
 156 komeda_plane_atomic_duplicate_state(struct drm_plane *plane)
 157 {
 158         struct komeda_plane_state *new;
 159
 160         if (WARN_ON(!plane->state))
 161                 return NULL;
 162
 163         new = kzalloc(sizeof(*new), GFP_KERNEL);
 164         if (!new)
 165                 return NULL;
 166
 167         __drm_atomic_helper_plane_duplicate_state(plane, &new->base);
 168
 169         return &new->base;
 170 }
 171
 172 static void
 173 komeda_plane_atomic_destroy_state(struct drm_plane *plane,
 174                                   struct drm_plane_state *state)
 175 {
 176         __drm_atomic_helper_plane_destroy_state(state);
 177         kfree(to_kplane_st(state));
 178 }
 179
 180 static bool
 181 komeda_plane_format_mod_supported(struct drm_plane *plane,
 182                                   u32 format, u64 modifier)
 183 {
 184         struct komeda_dev *mdev = plane->dev->dev_private;
 185         struct komeda_plane *kplane = to_kplane(plane);
 186         u32 layer_type = kplane->layer->layer_type;
 187
 188         return komeda_format_mod_supported(&mdev->fmt_tbl, layer_type,
 189                                            format, modifier, 0);
 190 }
 191
 192 static const struct drm_plane_funcs komeda_plane_funcs = {
 193         .update_plane           = drm_atomic_helper_update_plane,
 194         .disable_plane          = drm_atomic_helper_disable_plane,
 195         .destroy                = komeda_plane_destroy,
 196         .reset                  = komeda_plane_reset,
 197         .atomic_duplicate_state = komeda_plane_atomic_duplicate_state,
 198         .atomic_destroy_state   = komeda_plane_atomic_destroy_state,
 199         .format_mod_supported   = komeda_plane_format_mod_supported,
 200 };
 201
 202 /* for komeda, which is pipeline can be share between crtcs */
 203 static u32 get_possible_crtcs(struct komeda_kms_dev *kms,
 204                               struct komeda_pipeline *pipe)
 205 {
 206         struct komeda_crtc *crtc;
 207         u32 possible_crtcs = 0;
 208         int i;
 209
 210         for (i = 0; i < kms->n_crtcs; i++) {
 211                 crtc = &kms->crtcs[i];
 212
 213                 if ((pipe == crtc->master) || (pipe == crtc->slave))
 214                         possible_crtcs |= BIT(i);
 215         }
 216
 217         return possible_crtcs;
 218 }
 219
 220 static void
 221 komeda_set_crtc_plane_mask(struct komeda_kms_dev *kms,
 222                            struct komeda_pipeline *pipe,
 223                            struct drm_plane *plane)
 224 {
 225         struct komeda_crtc *kcrtc;
 226         int i;
 227
 228         for (i = 0; i < kms->n_crtcs; i++) {
 229                 kcrtc = &kms->crtcs[i];
 230
 231                 if (pipe == kcrtc->slave)
 232                         kcrtc->slave_planes |= BIT(drm_plane_index(plane));
 233         }
 234 }
 235
 236 /* use Layer0 as primary */
 237 static u32 get_plane_type(struct komeda_kms_dev *kms,
 238                           struct komeda_component *c)
 239 {
 240         bool is_primary = (c->id == KOMEDA_COMPONENT_LAYER0);
 241
 242         return is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
 243 }
 244
 245 static int komeda_plane_add(struct komeda_kms_dev *kms,
 246                             struct komeda_layer *layer)
 247 {
 248         struct komeda_dev *mdev = kms->base.dev_private;
 249         struct komeda_component *c = &layer->base;
 250         struct komeda_plane *kplane;
 251         struct drm_plane *plane;
 252         u32 *formats, n_formats = 0;
 253         int err;
 254
 255         kplane = kzalloc(sizeof(*kplane), GFP_KERNEL);
 256         if (!kplane)
 257                 return -ENOMEM;
 258
 259         plane = &kplane->base;
 260         kplane->layer = layer;
 261
 262         formats = komeda_get_layer_fourcc_list(&mdev->fmt_tbl,
 263                                                layer->layer_type, &n_formats);
 264
 265         err = drm_universal_plane_init(&kms->base, plane,
 266                         get_possible_crtcs(kms, c->pipeline),
 267                         &komeda_plane_funcs,
 268                         formats, n_formats, komeda_supported_modifiers,
 269                         get_plane_type(kms, c),
 270                         "%s", c->name);
 271
 272         komeda_put_fourcc_list(formats);
 273
 274         if (err)
 275                 goto cleanup;
 276
 277         drm_plane_helper_add(plane, &komeda_plane_helper_funcs);
 278
 279         err = drm_plane_create_rotation_property(plane, DRM_MODE_ROTATE_0,
 280                                                  layer->supported_rots);
 281         if (err)
 282                 goto cleanup;
 283
 284         err = drm_plane_create_alpha_property(plane);
 285         if (err)
 286                 goto cleanup;
 287
 288         err = drm_plane_create_blend_mode_property(plane,
 289                         BIT(DRM_MODE_BLEND_PIXEL_NONE) |
 290                         BIT(DRM_MODE_BLEND_PREMULTI)   |
 291                         BIT(DRM_MODE_BLEND_COVERAGE));
 292         if (err)
 293                 goto cleanup;
 294
 295         err = drm_plane_create_color_properties(plane,
 296                         BIT(DRM_COLOR_YCBCR_BT601) |
 297                         BIT(DRM_COLOR_YCBCR_BT709) |
 298                         BIT(DRM_COLOR_YCBCR_BT2020),
 299                         BIT(DRM_COLOR_YCBCR_LIMITED_RANGE) |
 300                         BIT(DRM_COLOR_YCBCR_FULL_RANGE),
 301                         DRM_COLOR_YCBCR_BT601,
 302                         DRM_COLOR_YCBCR_LIMITED_RANGE);
 303         if (err)
 304                 goto cleanup;
 305
 306         err = drm_plane_create_zpos_property(plane, layer->base.id, 0, 8);
 307         if (err)
 308                 goto cleanup;
 309
 310         komeda_set_crtc_plane_mask(kms, c->pipeline, plane);
 311
 312         return 0;
 313 cleanup:
 314         komeda_plane_destroy(plane);
 315         return err;
 316 }
 317
 318 int komeda_kms_add_planes(struct komeda_kms_dev *kms, struct komeda_dev *mdev)
 319 {
 320         struct komeda_pipeline *pipe;
 321         int i, j, err;
 322
 323         for (i = 0; i < mdev->n_pipelines; i++) {
 324                 pipe = mdev->pipelines[i];
 325
 326                 for (j = 0; j < pipe->n_layers; j++) {
 327                         err = komeda_plane_add(kms, pipe->layers[j]);
 328                         if (err)
 329                                 return err;
 330                 }
 331         }
 332
 333         return 0;
 334 }