Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bf220452 authored by Matt Roper's avatar Matt Roper Committed by Daniel Vetter
Browse files

Revert "drm/i915: Add two-stage ILK-style watermark programming (v10)" 

This reverts commit 396e33ae.

This commit was triggering some FIFO underrun warnings on ILK-IVB
platforms (but surprisingly not on HSW/BDW that share more or less the
same codepaths).  These underruns were caught by the continuous
integration (CI) system and could be reproduced consistently when
running the basic acceptance tests (BAT) on the affected platforms.

Note that this revert will cause a visible regression for some
end-users; the "flicker when mouse moves between monitors in X" issue
that was reported before this patch was merged will now return.  However
regressions that are visible to CI have higher priority since they
prevent proper testing of future patches on those platforms.  Hopefully
we'll be able to figure out the cause of the underruns quickly and
remerge an improved version of this patch to fix the regression.

Cc: Daniel Vetter <daniel@ffwll.ch>
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=93640


Signed-off-by: default avatarMatt Roper <matthew.d.roper@intel.com>
Reviewed-by: default avatarDaniel Vetter <daniel@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1453232584-8543-1-git-send-email-matthew.d.roper@intel.com


Signed-off-by: default avatarDaniel Vetter <daniel.vetter@ffwll.ch>
parent 18afd443

drivers/gpu/drm/i915/i915_dma.c

+0 −1
Original line number Diff line number Diff line
@@ -896,7 +896,6 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags) 
	mutex_init(&dev_priv->sb_lock);

	mutex_init(&dev_priv->modeset_restore_lock);

	mutex_init(&dev_priv->av_mutex);

	mutex_init(&dev_priv->wm.wm_mutex);



	intel_pm_setup(dev);

drivers/gpu/drm/i915/i915_drv.h

+1 −12
Original line number Diff line number Diff line
@@ -628,11 +628,7 @@ struct drm_i915_display_funcs { 
			  struct dpll *best_clock);

	int (*compute_pipe_wm)(struct intel_crtc *crtc,

			       struct drm_atomic_state *state);

	int (*compute_intermediate_wm)(struct drm_device *dev,

				       struct intel_crtc *intel_crtc,

				       struct intel_crtc_state *newstate);

	void (*initial_watermarks)(struct intel_crtc_state *cstate);

	void (*optimize_watermarks)(struct intel_crtc_state *cstate);

	void (*program_watermarks)(struct intel_crtc_state *cstate);

	void (*update_wm)(struct drm_crtc *crtc);

	int (*modeset_calc_cdclk)(struct drm_atomic_state *state);

	void (*modeset_commit_cdclk)(struct drm_atomic_state *state);
@@ -1938,13 +1934,6 @@ struct drm_i915_private { 
		};



		uint8_t max_level;



		/*

		 * Should be held around atomic WM register writing; also

		 * protects * intel_crtc->wm.active and

		 * cstate->wm.need_postvbl_update.

		 */

		struct mutex wm_mutex;

	} wm;



	struct i915_runtime_pm pm;

drivers/gpu/drm/i915/intel_atomic.c

+0 −1
Original line number Diff line number Diff line
@@ -97,7 +97,6 @@ intel_crtc_duplicate_state(struct drm_crtc *crtc) 
	crtc_state->disable_lp_wm = false;

	crtc_state->disable_cxsr = false;

	crtc_state->wm_changed = false;

	crtc_state->wm.need_postvbl_update = false;



	return &crtc_state->base;

}

drivers/gpu/drm/i915/intel_display.c

+4 −88
Original line number Diff line number Diff line
@@ -4833,42 +4833,7 @@ static void intel_pre_plane_update(struct intel_crtc *crtc) 
		intel_set_memory_cxsr(dev_priv, false);

	}



	/*

	 * IVB workaround: must disable low power watermarks for at least

	 * one frame before enabling scaling.  LP watermarks can be re-enabled

	 * when scaling is disabled.

	 *

	 * WaCxSRDisabledForSpriteScaling:ivb

	 */

	if (pipe_config->disable_lp_wm) {

		ilk_disable_lp_wm(dev);

		intel_wait_for_vblank(dev, crtc->pipe);

	}



	/*

	 * If we're doing a modeset, we're done.  No need to do any pre-vblank

	 * watermark programming here.

	 */

	if (needs_modeset(&pipe_config->base))

		return;



	/*

	 * For platforms that support atomic watermarks, program the

	 * 'intermediate' watermarks immediately.  On pre-gen9 platforms, these

	 * will be the intermediate values that are safe for both pre- and

	 * post- vblank; when vblank happens, the 'active' values will be set

	 * to the final 'target' values and we'll do this again to get the

	 * optimal watermarks.  For gen9+ platforms, the values we program here

	 * will be the final target values which will get automatically latched

	 * at vblank time; no further programming will be necessary.

	 *

	 * If a platform hasn't been transitioned to atomic watermarks yet,

	 * we'll continue to update watermarks the old way, if flags tell

	 * us to.

	 */

	if (dev_priv->display.initial_watermarks != NULL)

		dev_priv->display.initial_watermarks(pipe_config);

	else if (pipe_config->wm_changed)

	if (!needs_modeset(&pipe_config->base) && pipe_config->wm_changed)

		intel_update_watermarks(&crtc->base);

}
@@ -11914,11 +11879,6 @@ int intel_plane_atomic_calc_changes(struct drm_crtc_state *crtc_state, 
		pipe_config->wm_changed = true;

	}



	/* Pre-gen9 platforms need two-step watermark updates */

	if (pipe_config->wm_changed && INTEL_INFO(dev)->gen < 9 &&

	    dev_priv->display.optimize_watermarks)

		to_intel_crtc_state(crtc_state)->wm.need_postvbl_update = true;



	if (visible || was_visible)

		intel_crtc->atomic.fb_bits |=

			to_intel_plane(plane)->frontbuffer_bit;
@@ -12075,30 +12035,9 @@ static int intel_crtc_atomic_check(struct drm_crtc *crtc, 
	ret = 0;

	if (dev_priv->display.compute_pipe_wm) {

		ret = dev_priv->display.compute_pipe_wm(intel_crtc, state);

		if (ret) {

			DRM_DEBUG_KMS("Target pipe watermarks are invalid\n");

			return ret;

		}

	}



	if (dev_priv->display.compute_intermediate_wm &&

	    !to_intel_atomic_state(state)->skip_intermediate_wm) {

		if (WARN_ON(!dev_priv->display.compute_pipe_wm))

			return 0;



		/*

		 * Calculate 'intermediate' watermarks that satisfy both the

		 * old state and the new state.  We can program these

		 * immediately.

		 */

		ret = dev_priv->display.compute_intermediate_wm(crtc->dev,

								intel_crtc,

								pipe_config);

		if (ret) {

			DRM_DEBUG_KMS("No valid intermediate pipe watermarks are possible\n");

		if (ret)

			return ret;

	}

	}



	if (INTEL_INFO(dev)->gen >= 9) {

		if (mode_changed)
@@ -13562,7 +13501,6 @@ static int intel_atomic_commit(struct drm_device *dev, 
	struct drm_i915_private *dev_priv = dev->dev_private;

	struct drm_crtc_state *crtc_state;

	struct drm_crtc *crtc;

	struct intel_crtc_state *intel_cstate;

	int ret = 0, i;

	bool hw_check = intel_state->modeset;
@@ -13662,20 +13600,6 @@ static int intel_atomic_commit(struct drm_device *dev, 


	drm_atomic_helper_wait_for_vblanks(dev, state);



	/*

	 * Now that the vblank has passed, we can go ahead and program the

	 * optimal watermarks on platforms that need two-step watermark

	 * programming.

	 *

	 * TODO: Move this (and other cleanup) to an async worker eventually.

	 */

	for_each_crtc_in_state(state, crtc, crtc_state, i) {

		intel_cstate = to_intel_crtc_state(crtc->state);



		if (dev_priv->display.optimize_watermarks)

			dev_priv->display.optimize_watermarks(intel_cstate);

	}



	mutex_lock(&dev->struct_mutex);

	drm_atomic_helper_cleanup_planes(dev, state);

	mutex_unlock(&dev->struct_mutex);
@@ -15342,7 +15266,7 @@ static void sanitize_watermarks(struct drm_device *dev) 
	int i;



	/* Only supported on platforms that use atomic watermark design */

	if (!dev_priv->display.optimize_watermarks)

	if (!dev_priv->display.program_watermarks)

		return;



	/*
@@ -15363,13 +15287,6 @@ static void sanitize_watermarks(struct drm_device *dev) 
	if (WARN_ON(IS_ERR(state)))

		goto fail;



	/*

	 * Hardware readout is the only time we don't want to calculate

	 * intermediate watermarks (since we don't trust the current

	 * watermarks).

	 */

	to_intel_atomic_state(state)->skip_intermediate_wm = true;



	ret = intel_atomic_check(dev, state);

	if (ret) {

		/*
@@ -15392,8 +15309,7 @@ static void sanitize_watermarks(struct drm_device *dev) 
	for_each_crtc_in_state(state, crtc, cstate, i) {

		struct intel_crtc_state *cs = to_intel_crtc_state(cstate);



		cs->wm.need_postvbl_update = true;

		dev_priv->display.optimize_watermarks(cs);

		dev_priv->display.program_watermarks(cs);

	}



	drm_atomic_state_free(state);

drivers/gpu/drm/i915/intel_drv.h

+2 −26
Original line number Diff line number Diff line
@@ -260,12 +260,6 @@ struct intel_atomic_state { 


	struct intel_shared_dpll_config shared_dpll[I915_NUM_PLLS];

	struct intel_wm_config wm_config;



	/*

	 * Current watermarks can't be trusted during hardware readout, so

	 * don't bother calculating intermediate watermarks.

	 */

	bool skip_intermediate_wm;

};



struct intel_plane_state {
@@ -513,29 +507,13 @@ struct intel_crtc_state { 


	struct {

		/*

		 * Optimal watermarks, programmed post-vblank when this state

		 * is committed.

		 * optimal watermarks, programmed post-vblank when this state

		 * is committed

		 */

		union {

			struct intel_pipe_wm ilk;

			struct skl_pipe_wm skl;

		} optimal;



		/*

		 * Intermediate watermarks; these can be programmed immediately

		 * since they satisfy both the current configuration we're

		 * switching away from and the new configuration we're switching

		 * to.

		 */

		struct intel_pipe_wm intermediate;



		/*

		 * Platforms with two-step watermark programming will need to

		 * update watermark programming post-vblank to switch from the

		 * safe intermediate watermarks to the optimal final

		 * watermarks.

		 */

		bool need_postvbl_update;

	} wm;

};
@@ -622,7 +600,6 @@ struct intel_crtc { 
			struct intel_pipe_wm ilk;

			struct skl_pipe_wm skl;

		} active;



		/* allow CxSR on this pipe */

		bool cxsr_allowed;

	} wm;
@@ -1583,7 +1560,6 @@ void skl_wm_get_hw_state(struct drm_device *dev); 
void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv,

			  struct skl_ddb_allocation *ddb /* out */);

uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state *pipe_config);

bool ilk_disable_lp_wm(struct drm_device *dev);



/* intel_sdvo.c */

bool intel_sdvo_init(struct drm_device *dev,