imx/dcss/dcss-plane.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright 2019 NXP.
0004  */
0005
0006 #include <drm/drm_atomic.h>
0007 #include <drm/drm_atomic_helper.h>
0008 #include <drm/drm_blend.h>
0009 #include <drm/drm_fb_cma_helper.h>
0010 #include <drm/drm_framebuffer.h>
0011 #include <drm/drm_gem_atomic_helper.h>
0012 #include <drm/drm_gem_cma_helper.h>
0013
0014 #include "dcss-dev.h"
0015 #include "dcss-kms.h"
0016
0017 static const u32 dcss_common_formats[] = {
0018     /* RGB */
0019     DRM_FORMAT_ARGB8888,
0020     DRM_FORMAT_XRGB8888,
0021     DRM_FORMAT_ABGR8888,
0022     DRM_FORMAT_XBGR8888,
0023     DRM_FORMAT_RGBA8888,
0024     DRM_FORMAT_RGBX8888,
0025     DRM_FORMAT_BGRA8888,
0026     DRM_FORMAT_BGRX8888,
0027     DRM_FORMAT_XRGB2101010,
0028     DRM_FORMAT_XBGR2101010,
0029     DRM_FORMAT_RGBX1010102,
0030     DRM_FORMAT_BGRX1010102,
0031     DRM_FORMAT_ARGB2101010,
0032     DRM_FORMAT_ABGR2101010,
0033     DRM_FORMAT_RGBA1010102,
0034     DRM_FORMAT_BGRA1010102,
0035 };
0036
0037 static const u64 dcss_video_format_modifiers[] = {
0038     DRM_FORMAT_MOD_LINEAR,
0039     DRM_FORMAT_MOD_INVALID,
0040 };
0041
0042 static const u64 dcss_graphics_format_modifiers[] = {
0043     DRM_FORMAT_MOD_VIVANTE_TILED,
0044     DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
0045     DRM_FORMAT_MOD_LINEAR,
0046     DRM_FORMAT_MOD_INVALID,
0047 };
0048
0049 static inline struct dcss_plane *to_dcss_plane(struct drm_plane *p)
0050 {
0051     return container_of(p, struct dcss_plane, base);
0052 }
0053
0054 static inline bool dcss_plane_fb_is_linear(const struct drm_framebuffer *fb)
0055 {
0056     return ((fb->flags & DRM_MODE_FB_MODIFIERS) == 0) ||
0057            ((fb->flags & DRM_MODE_FB_MODIFIERS) != 0 &&
0058         fb->modifier == DRM_FORMAT_MOD_LINEAR);
0059 }
0060
0061 static void dcss_plane_destroy(struct drm_plane *plane)
0062 {
0063     struct dcss_plane *dcss_plane = container_of(plane, struct dcss_plane,
0064                              base);
0065
0066     drm_plane_cleanup(plane);
0067     kfree(dcss_plane);
0068 }
0069
0070 static bool dcss_plane_format_mod_supported(struct drm_plane *plane,
0071                         u32 format,
0072                         u64 modifier)
0073 {
0074     switch (plane->type) {
0075     case DRM_PLANE_TYPE_PRIMARY:
0076         switch (format) {
0077         case DRM_FORMAT_ARGB8888:
0078         case DRM_FORMAT_XRGB8888:
0079         case DRM_FORMAT_ARGB2101010:
0080             return modifier == DRM_FORMAT_MOD_LINEAR ||
0081                    modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
0082                    modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED;
0083         default:
0084             return modifier == DRM_FORMAT_MOD_LINEAR;
0085         }
0086         break;
0087     case DRM_PLANE_TYPE_OVERLAY:
0088         return modifier == DRM_FORMAT_MOD_LINEAR;
0089     default:
0090         return false;
0091     }
0092 }
0093
0094 static const struct drm_plane_funcs dcss_plane_funcs = {
0095     .update_plane       = drm_atomic_helper_update_plane,
0096     .disable_plane      = drm_atomic_helper_disable_plane,
0097     .destroy        = dcss_plane_destroy,
0098     .reset          = drm_atomic_helper_plane_reset,
0099     .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
0100     .atomic_destroy_state   = drm_atomic_helper_plane_destroy_state,
0101     .format_mod_supported   = dcss_plane_format_mod_supported,
0102 };
0103
0104 static bool dcss_plane_can_rotate(const struct drm_format_info *format,
0105                   bool mod_present, u64 modifier,
0106                   unsigned int rotation)
0107 {
0108     bool linear_format = !mod_present || modifier == DRM_FORMAT_MOD_LINEAR;
0109     u32 supported_rotation = DRM_MODE_ROTATE_0;
0110
0111     if (!format->is_yuv && linear_format)
0112         supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
0113                      DRM_MODE_REFLECT_MASK;
0114     else if (!format->is_yuv &&
0115          (modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
0116           modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED))
0117         supported_rotation = DRM_MODE_ROTATE_MASK |
0118                      DRM_MODE_REFLECT_MASK;
0119     else if (format->is_yuv && linear_format &&
0120          (format->format == DRM_FORMAT_NV12 ||
0121           format->format == DRM_FORMAT_NV21))
0122         supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
0123                      DRM_MODE_REFLECT_MASK;
0124
0125     return !!(rotation & supported_rotation);
0126 }
0127
0128 static bool dcss_plane_is_source_size_allowed(u16 src_w, u16 src_h, u32 pix_fmt)
0129 {
0130     if (src_w < 64 &&
0131         (pix_fmt == DRM_FORMAT_NV12 || pix_fmt == DRM_FORMAT_NV21))
0132         return false;
0133     else if (src_w < 32 &&
0134          (pix_fmt == DRM_FORMAT_UYVY || pix_fmt == DRM_FORMAT_VYUY ||
0135           pix_fmt == DRM_FORMAT_YUYV || pix_fmt == DRM_FORMAT_YVYU))
0136         return false;
0137
0138     return src_w >= 16 && src_h >= 8;
0139 }
0140
0141 static int dcss_plane_atomic_check(struct drm_plane *plane,
0142                    struct drm_atomic_state *state)
0143 {
0144     struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
0145                                          plane);
0146     struct dcss_plane *dcss_plane = to_dcss_plane(plane);
0147     struct dcss_dev *dcss = plane->dev->dev_private;
0148     struct drm_framebuffer *fb = new_plane_state->fb;
0149     bool is_primary_plane = plane->type == DRM_PLANE_TYPE_PRIMARY;
0150     struct drm_gem_cma_object *cma_obj;
0151     struct drm_crtc_state *crtc_state;
0152     int hdisplay, vdisplay;
0153     int min, max;
0154     int ret;
0155
0156     if (!fb || !new_plane_state->crtc)
0157         return 0;
0158
0159     cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
0160     WARN_ON(!cma_obj);
0161
0162     crtc_state = drm_atomic_get_existing_crtc_state(state,
0163                             new_plane_state->crtc);
0164
0165     hdisplay = crtc_state->adjusted_mode.hdisplay;
0166     vdisplay = crtc_state->adjusted_mode.vdisplay;
0167
0168     if (!dcss_plane_is_source_size_allowed(new_plane_state->src_w >> 16,
0169                            new_plane_state->src_h >> 16,
0170                            fb->format->format)) {
0171         DRM_DEBUG_KMS("Source plane size is not allowed!\n");
0172         return -EINVAL;
0173     }
0174
0175     dcss_scaler_get_min_max_ratios(dcss->scaler, dcss_plane->ch_num,
0176                        &min, &max);
0177
0178     ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
0179                           min, max, !is_primary_plane,
0180                           false);
0181     if (ret)
0182         return ret;
0183
0184     if (!new_plane_state->visible)
0185         return 0;
0186
0187     if (!dcss_plane_can_rotate(fb->format,
0188                    !!(fb->flags & DRM_MODE_FB_MODIFIERS),
0189                    fb->modifier,
0190                    new_plane_state->rotation)) {
0191         DRM_DEBUG_KMS("requested rotation is not allowed!\n");
0192         return -EINVAL;
0193     }
0194
0195     if ((new_plane_state->crtc_x < 0 || new_plane_state->crtc_y < 0 ||
0196          new_plane_state->crtc_x + new_plane_state->crtc_w > hdisplay ||
0197          new_plane_state->crtc_y + new_plane_state->crtc_h > vdisplay) &&
0198         !dcss_plane_fb_is_linear(fb)) {
0199         DRM_DEBUG_KMS("requested cropping operation is not allowed!\n");
0200         return -EINVAL;
0201     }
0202
0203     if ((fb->flags & DRM_MODE_FB_MODIFIERS) &&
0204         !plane->funcs->format_mod_supported(plane,
0205                 fb->format->format,
0206                 fb->modifier)) {
0207         DRM_DEBUG_KMS("Invalid modifier: %llx", fb->modifier);
0208         return -EINVAL;
0209     }
0210
0211     return 0;
0212 }
0213
0214 static void dcss_plane_atomic_set_base(struct dcss_plane *dcss_plane)
0215 {
0216     struct drm_plane *plane = &dcss_plane->base;
0217     struct drm_plane_state *state = plane->state;
0218     struct dcss_dev *dcss = plane->dev->dev_private;
0219     struct drm_framebuffer *fb = state->fb;
0220     const struct drm_format_info *format = fb->format;
0221     struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
0222     unsigned long p1_ba = 0, p2_ba = 0;
0223
0224     if (!format->is_yuv ||
0225         format->format == DRM_FORMAT_NV12 ||
0226         format->format == DRM_FORMAT_NV21)
0227         p1_ba = cma_obj->paddr + fb->offsets[0] +
0228             fb->pitches[0] * (state->src.y1 >> 16) +
0229             format->char_per_block[0] * (state->src.x1 >> 16);
0230     else if (format->format == DRM_FORMAT_UYVY ||
0231          format->format == DRM_FORMAT_VYUY ||
0232          format->format == DRM_FORMAT_YUYV ||
0233          format->format == DRM_FORMAT_YVYU)
0234         p1_ba = cma_obj->paddr + fb->offsets[0] +
0235             fb->pitches[0] * (state->src.y1 >> 16) +
0236             2 * format->char_per_block[0] * (state->src.x1 >> 17);
0237
0238     if (format->format == DRM_FORMAT_NV12 ||
0239         format->format == DRM_FORMAT_NV21)
0240         p2_ba = cma_obj->paddr + fb->offsets[1] +
0241             (((fb->pitches[1] >> 1) * (state->src.y1 >> 17) +
0242             (state->src.x1 >> 17)) << 1);
0243
0244     dcss_dpr_addr_set(dcss->dpr, dcss_plane->ch_num, p1_ba, p2_ba,
0245               fb->pitches[0]);
0246 }
0247
0248 static bool dcss_plane_needs_setup(struct drm_plane_state *state,
0249                    struct drm_plane_state *old_state)
0250 {
0251     struct drm_framebuffer *fb = state->fb;
0252     struct drm_framebuffer *old_fb = old_state->fb;
0253
0254     return state->crtc_x != old_state->crtc_x ||
0255            state->crtc_y != old_state->crtc_y ||
0256            state->crtc_w != old_state->crtc_w ||
0257            state->crtc_h != old_state->crtc_h ||
0258            state->src_x  != old_state->src_x  ||
0259            state->src_y  != old_state->src_y  ||
0260            state->src_w  != old_state->src_w  ||
0261            state->src_h  != old_state->src_h  ||
0262            fb->format->format != old_fb->format->format ||
0263            fb->modifier  != old_fb->modifier ||
0264            state->rotation != old_state->rotation ||
0265            state->scaling_filter != old_state->scaling_filter;
0266 }
0267
0268 static void dcss_plane_atomic_update(struct drm_plane *plane,
0269                      struct drm_atomic_state *state)
0270 {
0271     struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
0272                                        plane);
0273     struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
0274                                        plane);
0275     struct dcss_plane *dcss_plane = to_dcss_plane(plane);
0276     struct dcss_dev *dcss = plane->dev->dev_private;
0277     struct drm_framebuffer *fb = new_state->fb;
0278     struct drm_crtc_state *crtc_state;
0279     bool modifiers_present;
0280     u32 src_w, src_h, dst_w, dst_h;
0281     struct drm_rect src, dst;
0282     bool enable = true;
0283     bool is_rotation_90_or_270;
0284
0285     if (!fb || !new_state->crtc || !new_state->visible)
0286         return;
0287
0288     crtc_state = new_state->crtc->state;
0289     modifiers_present = !!(fb->flags & DRM_MODE_FB_MODIFIERS);
0290
0291     if (old_state->fb && !drm_atomic_crtc_needs_modeset(crtc_state) &&
0292         !dcss_plane_needs_setup(new_state, old_state)) {
0293         dcss_plane_atomic_set_base(dcss_plane);
0294         return;
0295     }
0296
0297     src = plane->state->src;
0298     dst = plane->state->dst;
0299
0300     /*
0301      * The width and height after clipping.
0302      */
0303     src_w = drm_rect_width(&src) >> 16;
0304     src_h = drm_rect_height(&src) >> 16;
0305     dst_w = drm_rect_width(&dst);
0306     dst_h = drm_rect_height(&dst);
0307
0308     if (plane->type == DRM_PLANE_TYPE_OVERLAY &&
0309         modifiers_present && fb->modifier == DRM_FORMAT_MOD_LINEAR)
0310         modifiers_present = false;
0311
0312     dcss_dpr_format_set(dcss->dpr, dcss_plane->ch_num,
0313                 new_state->fb->format,
0314                 modifiers_present ? fb->modifier :
0315                         DRM_FORMAT_MOD_LINEAR);
0316     dcss_dpr_set_res(dcss->dpr, dcss_plane->ch_num, src_w, src_h);
0317     dcss_dpr_set_rotation(dcss->dpr, dcss_plane->ch_num,
0318                   new_state->rotation);
0319
0320     dcss_plane_atomic_set_base(dcss_plane);
0321
0322     is_rotation_90_or_270 = new_state->rotation & (DRM_MODE_ROTATE_90 |
0323                            DRM_MODE_ROTATE_270);
0324
0325     dcss_scaler_set_filter(dcss->scaler, dcss_plane->ch_num,
0326                    new_state->scaling_filter);
0327
0328     dcss_scaler_setup(dcss->scaler, dcss_plane->ch_num,
0329               new_state->fb->format,
0330               is_rotation_90_or_270 ? src_h : src_w,
0331               is_rotation_90_or_270 ? src_w : src_h,
0332               dst_w, dst_h,
0333               drm_mode_vrefresh(&crtc_state->mode));
0334
0335     dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
0336                    dst.x1, dst.y1, dst_w, dst_h);
0337     dcss_dtg_plane_alpha_set(dcss->dtg, dcss_plane->ch_num,
0338                  fb->format, new_state->alpha >> 8);
0339
0340     if (!dcss_plane->ch_num && (new_state->alpha >> 8) == 0)
0341         enable = false;
0342
0343     dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, enable);
0344     dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, enable);
0345
0346     if (!enable)
0347         dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
0348                        0, 0, 0, 0);
0349
0350     dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, enable);
0351 }
0352
0353 static void dcss_plane_atomic_disable(struct drm_plane *plane,
0354                       struct drm_atomic_state *state)
0355 {
0356     struct dcss_plane *dcss_plane = to_dcss_plane(plane);
0357     struct dcss_dev *dcss = plane->dev->dev_private;
0358
0359     dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, false);
0360     dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, false);
0361     dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num, 0, 0, 0, 0);
0362     dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, false);
0363 }
0364
0365 static const struct drm_plane_helper_funcs dcss_plane_helper_funcs = {
0366     .atomic_check = dcss_plane_atomic_check,
0367     .atomic_update = dcss_plane_atomic_update,
0368     .atomic_disable = dcss_plane_atomic_disable,
0369 };
0370
0371 struct dcss_plane *dcss_plane_init(struct drm_device *drm,
0372                    unsigned int possible_crtcs,
0373                    enum drm_plane_type type,
0374                    unsigned int zpos)
0375 {
0376     struct dcss_plane *dcss_plane;
0377     const u64 *format_modifiers = dcss_video_format_modifiers;
0378     int ret;
0379
0380     if (zpos > 2)
0381         return ERR_PTR(-EINVAL);
0382
0383     dcss_plane = kzalloc(sizeof(*dcss_plane), GFP_KERNEL);
0384     if (!dcss_plane) {
0385         DRM_ERROR("failed to allocate plane\n");
0386         return ERR_PTR(-ENOMEM);
0387     }
0388
0389     if (type == DRM_PLANE_TYPE_PRIMARY)
0390         format_modifiers = dcss_graphics_format_modifiers;
0391
0392     ret = drm_universal_plane_init(drm, &dcss_plane->base, possible_crtcs,
0393                        &dcss_plane_funcs, dcss_common_formats,
0394                        ARRAY_SIZE(dcss_common_formats),
0395                        format_modifiers, type, NULL);
0396     if (ret) {
0397         DRM_ERROR("failed to initialize plane\n");
0398         kfree(dcss_plane);
0399         return ERR_PTR(ret);
0400     }
0401
0402     drm_plane_helper_add(&dcss_plane->base, &dcss_plane_helper_funcs);
0403
0404     ret = drm_plane_create_zpos_immutable_property(&dcss_plane->base, zpos);
0405     if (ret)
0406         return ERR_PTR(ret);
0407
0408     drm_plane_create_scaling_filter_property(&dcss_plane->base,
0409                     BIT(DRM_SCALING_FILTER_DEFAULT) |
0410                     BIT(DRM_SCALING_FILTER_NEAREST_NEIGHBOR));
0411
0412     drm_plane_create_rotation_property(&dcss_plane->base,
0413                        DRM_MODE_ROTATE_0,
0414                        DRM_MODE_ROTATE_0   |
0415                        DRM_MODE_ROTATE_90  |
0416                        DRM_MODE_ROTATE_180 |
0417                        DRM_MODE_ROTATE_270 |
0418                        DRM_MODE_REFLECT_X  |
0419                        DRM_MODE_REFLECT_Y);
0420
0421     dcss_plane->ch_num = zpos;
0422
0423     return dcss_plane;
0424 }