drm/i915/display/fbc: Make fences a nice-to-have for GEN9+

dGFX has local memory so it does not have aperture or support
CPU fences but even for iGFX it have a small number of fences.

As replacement for fences to track frontbuffer modifications by CPU
we have a software tracking that is already in used by FBC and PSR.
PSR don't support fences so it shows that this tracking is reliable.

So lets make fences a nice-to-have to activate FBC for GEN9+, this
will allow us to enable FBC for dGFXs and iGFXs even when there is no
available fence.

We do not set fences to rotated planes but FBC only have restrictions
against 16bpp, so adding it here.

Also adding a new check for the tiling format, fences are only set
to X and Y tiled planes but again FBC don't have any restrictions
against tiling so adding linear as supported as well, other formats
should be added after tested but IGT only supports drawing in thse
3 formats.

intel_fbc_hw_tracking_covers_screen() maybe can also have the same
treatment as fences but BSpec is not clear if the size limitation is
for hardware tracking or general use of FBC and I don't have a 5K
display to test it, so keeping as is for safety.

v2:
- Added tiling and pixel format rotation checks
- Changed the GEN version not requiring fences to 11 from 9, DDX
needs some changes but it don't have support for GEN11+

v3:
- Changed back to GEN9+
- Moved GEN test to inside of tiling_is_valid()

v4:
- moved rotation check to its own functions

v5:
- renamed rotations_is_valid to rotation_is_valid
- moved pre-g4x rotation check to rotation_is_valid()

Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Dhinakaran Pandiyan <dhinakaran.pandiyan@intel.com>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: José Roberto de Souza <jose.souza@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200319211535.114625-1-jose.souza@intel.com

diff --git a/drivers/gpu/drm/i915/display/intel_fbc.c b/drivers/gpu/drm/i915/display/intel_fbc.c
index 02be14b693d4f2f2a7b2a3babd6cf11d71cafa93..56bcd6c52a02c42c354ec77cf48286d3f6f389e7 100644 (file)
--- a/drivers/gpu/drm/i915/display/intel_fbc.c
+++ b/drivers/gpu/drm/i915/display/intel_fbc.c
@@ -608,6 +608,19 @@ static bool pixel_format_is_valid(struct drm_i915_private *dev_priv,
        }
 }
 
+static bool rotation_is_valid(struct drm_i915_private *dev_priv,
+                             u32 pixel_format, unsigned int rotation)
+{
+       if (INTEL_GEN(dev_priv) >= 9 && pixel_format == DRM_FORMAT_RGB565 &&
+           drm_rotation_90_or_270(rotation))
+               return false;
+       else if (INTEL_GEN(dev_priv) <= 4 && !IS_G4X(dev_priv) &&
+                rotation != DRM_MODE_ROTATE_0)
+               return false;
+
+       return true;
+}
+
 /*
  * For some reason, the hardware tracking starts looking at whatever we
  * programmed as the display plane base address register. It does not look at
@@ -642,6 +655,22 @@ static bool intel_fbc_hw_tracking_covers_screen(struct intel_crtc *crtc)
        return effective_w <= max_w && effective_h <= max_h;
 }
 
+static bool tiling_is_valid(struct drm_i915_private *dev_priv,
+                           uint64_t modifier)
+{
+       switch (modifier) {
+       case DRM_FORMAT_MOD_LINEAR:
+               if (INTEL_GEN(dev_priv) >= 9)
+                       return true;
+               return false;
+       case I915_FORMAT_MOD_X_TILED:
+       case I915_FORMAT_MOD_Y_TILED:
+               return true;
+       default:
+               return false;
+       }
+}
+
 static void intel_fbc_update_state_cache(struct intel_crtc *crtc,
                                         const struct intel_crtc_state *crtc_state,
                                         const struct intel_plane_state *plane_state)
@@ -675,6 +704,7 @@ static void intel_fbc_update_state_cache(struct intel_crtc *crtc,
 
        cache->fb.format = fb->format;
        cache->fb.stride = fb->pitches[0];
+       cache->fb.modifier = fb->modifier;
 
        drm_WARN_ON(&dev_priv->drm, plane_state->flags & PLANE_HAS_FENCE &&
                    !plane_state->vma->fence);
@@ -748,29 +778,39 @@ static bool intel_fbc_can_activate(struct intel_crtc *crtc)
                return false;
        }
 
-       /* The use of a CPU fence is mandatory in order to detect writes
-        * by the CPU to the scanout and trigger updates to the FBC.
+       /* The use of a CPU fence is one of two ways to detect writes by the
+        * CPU to the scanout and trigger updates to the FBC.
+        *
+        * The other method is by software tracking (see
+        * intel_fbc_invalidate/flush()), it will manually notify FBC and nuke
+        * the current compressed buffer and recompress it.
         *
         * Note that is possible for a tiled surface to be unmappable (and
-        * so have no fence associated with it) due to aperture constaints
+        * so have no fence associated with it) due to aperture constraints
         * at the time of pinning.
         *
         * FIXME with 90/270 degree rotation we should use the fence on
         * the normal GTT view (the rotated view doesn't even have a
         * fence). Would need changes to the FBC fence Y offset as well.
-        * For now this will effecively disable FBC with 90/270 degree
+        * For now this will effectively disable FBC with 90/270 degree
         * rotation.
         */
-       if (cache->fence_id < 0) {
+       if (INTEL_GEN(dev_priv) < 9 && cache->fence_id < 0) {
                fbc->no_fbc_reason = "framebuffer not tiled or fenced";
                return false;
        }
-       if (INTEL_GEN(dev_priv) <= 4 && !IS_G4X(dev_priv) &&
-           cache->plane.rotation != DRM_MODE_ROTATE_0) {
+
+       if (!rotation_is_valid(dev_priv, cache->fb.format->format,
+                              cache->plane.rotation)) {
                fbc->no_fbc_reason = "rotation unsupported";
                return false;
        }
 
+       if (!tiling_is_valid(dev_priv, cache->fb.modifier)) {
+               fbc->no_fbc_reason = "tiling unsupported";
+               return false;
+       }
+
        if (!stride_is_valid(dev_priv, cache->fb.stride)) {
                fbc->no_fbc_reason = "framebuffer stride not supported";
                return false;

diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index a7ea1d8553598eb72e3c9172beb5b8cc72c0700f..9bcea97c39de444fb43375a2d24f14690f0f5620 100644 (file)
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -416,6 +416,7 @@ struct intel_fbc {
                struct {
                        const struct drm_format_info *format;
                        unsigned int stride;
+                       u64 modifier;
                } fb;
                u16 gen9_wa_cfb_stride;
                s8 fence_id;