Quelle  omap_plane.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/
 * Author: Rob Clark <rob.clark@linaro.org>
 */

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_blend.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_framebuffer.h>

#include "omap_dmm_tiler.h"
#include "omap_drv.h"

/*
 * plane funcs
 */

#define to_omap_plane_state(x) container_of(x, struct omap_plane_state, base)

struct omap_plane_state {
 /* Must be first. */
 struct drm_plane_state base;

 struct omap_hw_overlay *overlay;
 struct omap_hw_overlay *r_overlay;  /* right overlay */
};

#define to_omap_plane(x) container_of(x, struct omap_plane, base)

struct omap_plane {
 struct drm_plane base;
 enum omap_plane_id id;
};

bool is_omap_plane_dual_overlay(struct drm_plane_state *state)
{
 struct omap_plane_state *omap_state = to_omap_plane_state(state);

 return !!omap_state->r_overlay;
}

static int omap_plane_prepare_fb(struct drm_plane *plane,
     struct drm_plane_state *new_state)
{
 if (!new_state->fb)
  return 0;

 drm_gem_plane_helper_prepare_fb(plane, new_state);

 return omap_framebuffer_pin(new_state->fb);
}

static void omap_plane_cleanup_fb(struct drm_plane *plane,
      struct drm_plane_state *old_state)
{
 if (old_state->fb)
  omap_framebuffer_unpin(old_state->fb);
}

static void omap_plane_atomic_update(struct drm_plane *plane,
         struct drm_atomic_state *state)
{
 struct omap_drm_private *priv = plane->dev->dev_private;
 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
            plane);
 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
            plane);
 struct omap_plane_state *new_omap_state;
 struct omap_plane_state *old_omap_state;
 struct omap_overlay_info info, r_info;
 enum omap_plane_id ovl_id, r_ovl_id;
 int ret;
 bool dual_ovl;

 new_omap_state = to_omap_plane_state(new_state);
 old_omap_state = to_omap_plane_state(old_state);

 dual_ovl = is_omap_plane_dual_overlay(new_state);

 /* Cleanup previously held overlay if needed */
 if (old_omap_state->overlay)
  omap_overlay_update_state(priv, old_omap_state->overlay);
 if (old_omap_state->r_overlay)
  omap_overlay_update_state(priv, old_omap_state->r_overlay);

 if (!new_omap_state->overlay) {
  DBG("[PLANE:%d:%s] no overlay attached", plane->base.id, plane->name);
  return;
 }

 ovl_id = new_omap_state->overlay->id;
 DBG("%s, crtc=%p fb=%p", plane->name, new_state->crtc,
     new_state->fb);

 memset(&info, 0, sizeof(info));
 info.rotation_type = OMAP_DSS_ROT_NONE;
 info.rotation = DRM_MODE_ROTATE_0;
 info.global_alpha = new_state->alpha >> 8;
 info.zorder = new_state->normalized_zpos;
 if (new_state->pixel_blend_mode == DRM_MODE_BLEND_PREMULTI)
  info.pre_mult_alpha = 1;
 else
  info.pre_mult_alpha = 0;
 info.color_encoding = new_state->color_encoding;
 info.color_range = new_state->color_range;

 r_info = info;

 /* update scanout: */
 omap_framebuffer_update_scanout(new_state->fb, new_state, &info,
     dual_ovl ? &r_info : NULL);

 DBG("%s: %dx%d -> %dx%d (%d)",
   new_omap_state->overlay->name, info.width, info.height,
   info.out_width, info.out_height, info.screen_width);
 DBG("%d,%d %pad %pad", info.pos_x, info.pos_y,
   &info.paddr, &info.p_uv_addr);

 if (dual_ovl) {
  r_ovl_id = new_omap_state->r_overlay->id;
  /*
 * If the current plane uses 2 hw planes the very next
 * zorder is used by the r_overlay so we just use the
 * main overlay zorder + 1
 */
  r_info.zorder = info.zorder + 1;

  DBG("%s: %dx%d -> %dx%d (%d)",
      new_omap_state->r_overlay->name,
      r_info.width, r_info.height,
      r_info.out_width, r_info.out_height, r_info.screen_width);
  DBG("%d,%d %pad %pad", r_info.pos_x, r_info.pos_y,
      &r_info.paddr, &r_info.p_uv_addr);
 }

 /* and finally, update omapdss: */
 ret = dispc_ovl_setup(priv->dispc, ovl_id, &info,
         omap_crtc_timings(new_state->crtc), false,
         omap_crtc_channel(new_state->crtc));
 if (ret) {
  dev_err(plane->dev->dev, "Failed to setup plane %s\n",
   plane->name);
  dispc_ovl_enable(priv->dispc, ovl_id, false);
  return;
 }

 dispc_ovl_enable(priv->dispc, ovl_id, true);

 if (dual_ovl) {
  ret = dispc_ovl_setup(priv->dispc, r_ovl_id, &r_info,
          omap_crtc_timings(new_state->crtc), false,
          omap_crtc_channel(new_state->crtc));
  if (ret) {
   dev_err(plane->dev->dev, "Failed to setup plane right-overlay %s\n",
    plane->name);
   dispc_ovl_enable(priv->dispc, r_ovl_id, false);
   dispc_ovl_enable(priv->dispc, ovl_id, false);
   return;
  }

  dispc_ovl_enable(priv->dispc, r_ovl_id, true);
 }
}

static void omap_plane_atomic_disable(struct drm_plane *plane,
          struct drm_atomic_state *state)
{
 struct omap_drm_private *priv = plane->dev->dev_private;
 struct omap_plane *omap_plane = to_omap_plane(plane);
 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
            plane);
 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
            plane);
 struct omap_plane_state *new_omap_state;
 struct omap_plane_state *old_omap_state;

 new_omap_state = to_omap_plane_state(new_state);
 old_omap_state = to_omap_plane_state(old_state);

 if (!old_omap_state->overlay)
  return;

 new_state->rotation = DRM_MODE_ROTATE_0;
 new_state->zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : omap_plane->id;

 omap_overlay_update_state(priv, old_omap_state->overlay);
 new_omap_state->overlay = NULL;

 if (is_omap_plane_dual_overlay(old_state)) {
  omap_overlay_update_state(priv, old_omap_state->r_overlay);
  new_omap_state->r_overlay = NULL;
 }
}

#define FRAC_16_16(mult, div)    (((mult) << 16) / (div))

static int omap_plane_atomic_check(struct drm_plane *plane,
       struct drm_atomic_state *state)
{
 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
           plane);
 struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
           plane);
 struct omap_drm_private *priv = plane->dev->dev_private;
 struct omap_plane_state *omap_state = to_omap_plane_state(new_plane_state);
 struct omap_global_state *omap_overlay_global_state;
 struct drm_crtc_state *crtc_state;
 bool new_r_hw_overlay = false;
 bool new_hw_overlay = false;
 u32 max_width, max_height;
 struct drm_crtc *crtc;
 u16 width, height;
 u32 caps = 0;
 u32 fourcc;
 int ret;

 omap_overlay_global_state = omap_get_global_state(state);
 if (IS_ERR(omap_overlay_global_state))
  return PTR_ERR(omap_overlay_global_state);

 dispc_ovl_get_max_size(priv->dispc, &width, &height);
 max_width = width << 16;
 max_height = height << 16;

 crtc = new_plane_state->crtc ? new_plane_state->crtc : plane->state->crtc;
 if (!crtc)
  return 0;

 crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
 /* we should have a crtc state if the plane is attached to a crtc */
 if (WARN_ON(!crtc_state))
  return 0;

 /*
 * Note: these are just sanity checks to filter out totally bad scaling
 * factors. The real limits must be calculated case by case, and
 * unfortunately we currently do those checks only at the commit
 * phase in dispc.
 */
 ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
        FRAC_16_16(1, 8), FRAC_16_16(8, 1),
        true, true);
 if (ret)
  return ret;

 DBG("%s: visible %d -> %d", plane->name,
     old_plane_state->visible, new_plane_state->visible);

 if (!new_plane_state->visible) {
  omap_overlay_release(state, omap_state->overlay);
  omap_overlay_release(state, omap_state->r_overlay);
  omap_state->overlay = NULL;
  omap_state->r_overlay = NULL;
  return 0;
 }

 if (new_plane_state->crtc_x < 0 || new_plane_state->crtc_y < 0)
  return -EINVAL;

 if (new_plane_state->crtc_x + new_plane_state->crtc_w > crtc_state->adjusted_mode.hdisplay)
  return -EINVAL;

 if (new_plane_state->crtc_y + new_plane_state->crtc_h > crtc_state->adjusted_mode.vdisplay)
  return -EINVAL;

 /* Make sure dimensions are within bounds. */
 if (new_plane_state->src_h > max_height || new_plane_state->crtc_h > height)
  return -EINVAL;


 if (new_plane_state->src_w > max_width || new_plane_state->crtc_w > width) {
  bool is_fourcc_yuv = new_plane_state->fb->format->is_yuv;

  if (is_fourcc_yuv && (((new_plane_state->src_w >> 16) / 2 & 1) ||
          new_plane_state->crtc_w / 2 & 1)) {
   /*
 * When calculating the split overlay width
 * and it yield an odd value we will need to adjust
 * the indivual width +/- 1. So make sure it fits
 */
   if (new_plane_state->src_w <= ((2 * width - 1) << 16) &&
       new_plane_state->crtc_w <= (2 * width - 1))
    new_r_hw_overlay = true;
   else
    return -EINVAL;
  } else {
   if (new_plane_state->src_w <= (2 * max_width) &&
       new_plane_state->crtc_w <= (2 * width))
    new_r_hw_overlay = true;
   else
    return -EINVAL;
  }
 }

 if (new_plane_state->rotation != DRM_MODE_ROTATE_0 &&
     !omap_framebuffer_supports_rotation(new_plane_state->fb))
  return -EINVAL;

 if ((new_plane_state->src_w >> 16) != new_plane_state->crtc_w ||
     (new_plane_state->src_h >> 16) != new_plane_state->crtc_h)
  caps |= OMAP_DSS_OVL_CAP_SCALE;

 fourcc = new_plane_state->fb->format->format;

 /*
 * (re)allocate hw overlay if we don't have one or
 * there is a caps mismatch
 */
 if (!omap_state->overlay || (caps & ~omap_state->overlay->caps)) {
  new_hw_overlay = true;
 } else {
  /* check supported format */
  if (!dispc_ovl_color_mode_supported(priv->dispc, omap_state->overlay->id,
          fourcc))
   new_hw_overlay = true;
 }

 /*
 * check if we need two overlays and only have 1 or
 * if we had 2 overlays but will only need 1
 */
 if ((new_r_hw_overlay && !omap_state->r_overlay) ||
     (!new_r_hw_overlay && omap_state->r_overlay))
  new_hw_overlay = true;

 if (new_hw_overlay) {
  struct omap_hw_overlay *old_ovl = omap_state->overlay;
  struct omap_hw_overlay *old_r_ovl = omap_state->r_overlay;
  struct omap_hw_overlay *new_ovl = NULL;
  struct omap_hw_overlay *new_r_ovl = NULL;

  omap_overlay_release(state, old_ovl);
  omap_overlay_release(state, old_r_ovl);

  ret = omap_overlay_assign(state, plane, caps, fourcc, &new_ovl,
       new_r_hw_overlay ? &new_r_ovl : NULL);
  if (ret) {
   DBG("%s: failed to assign hw_overlay", plane->name);
   omap_state->overlay = NULL;
   omap_state->r_overlay = NULL;
   return ret;
  }

  omap_state->overlay = new_ovl;
  if (new_r_hw_overlay)
   omap_state->r_overlay = new_r_ovl;
  else
   omap_state->r_overlay = NULL;
 }

 DBG("plane: %s overlay_id: %d", plane->name, omap_state->overlay->id);

 if (omap_state->r_overlay)
  DBG("plane: %s r_overlay_id: %d", plane->name, omap_state->r_overlay->id);

 return 0;
}

static const struct drm_plane_helper_funcs omap_plane_helper_funcs = {
 .prepare_fb = omap_plane_prepare_fb,
 .cleanup_fb = omap_plane_cleanup_fb,
 .atomic_check = omap_plane_atomic_check,
 .atomic_update = omap_plane_atomic_update,
 .atomic_disable = omap_plane_atomic_disable,
};

static void omap_plane_destroy(struct drm_plane *plane)
{
 struct omap_plane *omap_plane = to_omap_plane(plane);

 DBG("%s", plane->name);

 drm_plane_cleanup(plane);

 kfree(omap_plane);
}

/* helper to install properties which are common to planes and crtcs */
void omap_plane_install_properties(struct drm_plane *plane,
  struct drm_mode_object *obj)
{
 struct drm_device *dev = plane->dev;
 struct omap_drm_private *priv = dev->dev_private;

 if (priv->has_dmm) {
  if (!plane->rotation_property)
   drm_plane_create_rotation_property(plane,
          DRM_MODE_ROTATE_0,
          DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 |
          DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270 |
          DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y);

  /* Attach the rotation property also to the crtc object */
  if (plane->rotation_property && obj != &plane->base)
   drm_object_attach_property(obj, plane->rotation_property,
         DRM_MODE_ROTATE_0);
 }

 drm_object_attach_property(obj, priv->zorder_prop, 0);
}

static void omap_plane_reset(struct drm_plane *plane)
{
 struct omap_plane_state *omap_state;

 if (plane->state)
  drm_atomic_helper_plane_destroy_state(plane, plane->state);

 omap_state = kzalloc(sizeof(*omap_state), GFP_KERNEL);
 if (!omap_state)
  return;

 __drm_atomic_helper_plane_reset(plane, &omap_state->base);
}

static struct drm_plane_state *
omap_plane_atomic_duplicate_state(struct drm_plane *plane)
{
 struct omap_plane_state *state, *current_state;

 if (WARN_ON(!plane->state))
  return NULL;

 current_state = to_omap_plane_state(plane->state);

 state = kmalloc(sizeof(*state), GFP_KERNEL);
 if (!state)
  return NULL;

 __drm_atomic_helper_plane_duplicate_state(plane, &state->base);

 state->overlay = current_state->overlay;
 state->r_overlay = current_state->r_overlay;

 return &state->base;
}

static void omap_plane_atomic_print_state(struct drm_printer *p,
       const struct drm_plane_state *state)
{
 struct omap_plane_state *omap_state = to_omap_plane_state(state);

 if (omap_state->overlay)
  drm_printf(p, "\toverlay=%s (caps=0x%x)\n",
      omap_state->overlay->name,
      omap_state->overlay->caps);
 else
  drm_printf(p, "\toverlay=None\n");
 if (omap_state->r_overlay)
  drm_printf(p, "\tr_overlay=%s (caps=0x%x)\n",
      omap_state->r_overlay->name,
      omap_state->r_overlay->caps);
 else
  drm_printf(p, "\tr_overlay=None\n");
}

static int omap_plane_atomic_set_property(struct drm_plane *plane,
       struct drm_plane_state *state,
       struct drm_property *property,
       u64 val)
{
 struct omap_drm_private *priv = plane->dev->dev_private;

 if (property == priv->zorder_prop)
  state->zpos = val;
 else
  return -EINVAL;

 return 0;
}

static int omap_plane_atomic_get_property(struct drm_plane *plane,
       const struct drm_plane_state *state,
       struct drm_property *property,
       u64 *val)
{
 struct omap_drm_private *priv = plane->dev->dev_private;

 if (property == priv->zorder_prop)
  *val = state->zpos;
 else
  return -EINVAL;

 return 0;
}

static const struct drm_plane_funcs omap_plane_funcs = {
 .update_plane = drm_atomic_helper_update_plane,
 .disable_plane = drm_atomic_helper_disable_plane,
 .reset = omap_plane_reset,
 .destroy = omap_plane_destroy,
 .atomic_duplicate_state = omap_plane_atomic_duplicate_state,
 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
 .atomic_set_property = omap_plane_atomic_set_property,
 .atomic_get_property = omap_plane_atomic_get_property,
 .atomic_print_state = omap_plane_atomic_print_state,
};

static bool omap_plane_supports_yuv(struct drm_plane *plane)
{
 struct omap_drm_private *priv = plane->dev->dev_private;
 struct omap_plane *omap_plane = to_omap_plane(plane);
 const u32 *formats = dispc_ovl_get_color_modes(priv->dispc, omap_plane->id);
 u32 i;

 for (i = 0; formats[i]; i++)
  if (formats[i] == DRM_FORMAT_YUYV ||
      formats[i] == DRM_FORMAT_UYVY ||
      formats[i] == DRM_FORMAT_NV12)
   return true;

 return false;
}

/* initialize plane */
struct drm_plane *omap_plane_init(struct drm_device *dev,
  int idx, enum drm_plane_type type,
  u32 possible_crtcs)
{
 struct omap_drm_private *priv = dev->dev_private;
 unsigned int num_planes = dispc_get_num_ovls(priv->dispc);
 struct drm_plane *plane;
 struct omap_plane *omap_plane;
 unsigned int zpos;
 int ret;
 u32 nformats;
 const u32 *formats;

 if (WARN_ON(idx >= num_planes))
  return ERR_PTR(-EINVAL);

 omap_plane = kzalloc(sizeof(*omap_plane), GFP_KERNEL);
 if (!omap_plane)
  return ERR_PTR(-ENOMEM);

 omap_plane->id = idx;

 DBG("%d: type=%d", omap_plane->id, type);
 DBG(" crtc_mask: 0x%04x", possible_crtcs);

 formats = dispc_ovl_get_color_modes(priv->dispc, omap_plane->id);
 for (nformats = 0; formats[nformats]; ++nformats)
  ;

 plane = &omap_plane->base;

 ret = drm_universal_plane_init(dev, plane, possible_crtcs,
           &omap_plane_funcs, formats,
           nformats, NULL, type, NULL);
 if (ret < 0)
  goto error;

 drm_plane_helper_add(plane, &omap_plane_helper_funcs);

 omap_plane_install_properties(plane, &plane->base);

 /*
 * Set the zpos default depending on whether we are a primary or overlay
 * plane.
 */
 if (plane->type == DRM_PLANE_TYPE_PRIMARY)
  zpos = 0;
 else
  zpos = omap_plane->id;
 drm_plane_create_zpos_property(plane, zpos, 0, num_planes - 1);
 drm_plane_create_alpha_property(plane);
 drm_plane_create_blend_mode_property(plane, BIT(DRM_MODE_BLEND_PREMULTI) |
          BIT(DRM_MODE_BLEND_COVERAGE));

 if (omap_plane_supports_yuv(plane))
  drm_plane_create_color_properties(plane,
        BIT(DRM_COLOR_YCBCR_BT601) |
        BIT(DRM_COLOR_YCBCR_BT709),
        BIT(DRM_COLOR_YCBCR_FULL_RANGE) |
        BIT(DRM_COLOR_YCBCR_LIMITED_RANGE),
        DRM_COLOR_YCBCR_BT601,
        DRM_COLOR_YCBCR_FULL_RANGE);

 return plane;

error:
 dev_err(dev->dev, "%s(): could not create plane: %d\n",
  __func__, omap_plane->id);

 kfree(omap_plane);
 return NULL;
}