drm: Measure Self Refresh Entry/Exit times to avoid thrashing (d4da4e33) · Commits · 戴 / test

drivers/gpu/drm/drm_atomic_helper.c

+20 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@
	*/		*/

	#include <linux/dma-fence.h>		#include <linux/dma-fence.h>
			#include <linux/ktime.h>

	#include <drm/drm_atomic.h>		#include <drm/drm_atomic.h>
	#include <drm/drm_atomic_helper.h>		#include <drm/drm_atomic_helper.h>
	@@ -1580,9 +1581,23 @@ static void commit_tail(struct drm_atomic_state *old_state)
	{		{
	struct drm_device *dev = old_state->dev;		struct drm_device *dev = old_state->dev;
	const struct drm_mode_config_helper_funcs *funcs;		const struct drm_mode_config_helper_funcs *funcs;
			ktime_t start;
			s64 commit_time_ms;

	funcs = dev->mode_config.helper_private;		funcs = dev->mode_config.helper_private;

			/*
			* We're measuring the _entire_ commit, so the time will vary depending
			* on how many fences and objects are involved. For the purposes of self
			* refresh, this is desirable since it'll give us an idea of how
			* congested things are. This will inform our decision on how often we
			* should enter self refresh after idle.
			*
			* These times will be averaged out in the self refresh helpers to avoid
			* overreacting over one outlier frame
			*/
			start = ktime_get();

	drm_atomic_helper_wait_for_fences(dev, old_state, false);		drm_atomic_helper_wait_for_fences(dev, old_state, false);

	drm_atomic_helper_wait_for_dependencies(old_state);		drm_atomic_helper_wait_for_dependencies(old_state);
	@@ -1592,6 +1607,11 @@ static void commit_tail(struct drm_atomic_state *old_state)
	else		else
	drm_atomic_helper_commit_tail(old_state);		drm_atomic_helper_commit_tail(old_state);

			commit_time_ms = ktime_ms_delta(ktime_get(), start);
			if (commit_time_ms > 0)
			drm_self_refresh_helper_update_avg_times(old_state,
			(unsigned long)commit_time_ms);

	drm_atomic_helper_commit_cleanup_done(old_state);		drm_atomic_helper_commit_cleanup_done(old_state);

	drm_atomic_state_put(old_state);		drm_atomic_state_put(old_state);

drivers/gpu/drm/drm_self_refresh_helper.c

+66 −6

Original line number	Original line	Diff line number	Diff line
	@@ -5,6 +5,7 @@
	* Authors:		* Authors:
	* Sean Paul <seanpaul@chromium.org>		* Sean Paul <seanpaul@chromium.org>
	*/		*/
			#include <linux/average.h>
	#include <linux/bitops.h>		#include <linux/bitops.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>
	@@ -50,10 +51,17 @@
	* atomic_check when &drm_crtc_state.self_refresh_active is true.		* atomic_check when &drm_crtc_state.self_refresh_active is true.
	*/		*/

			#define SELF_REFRESH_AVG_SEED_MS 200

			DECLARE_EWMA(psr_time, 4, 4)

	struct drm_self_refresh_data {		struct drm_self_refresh_data {
	struct drm_crtc *crtc;		struct drm_crtc *crtc;
	struct delayed_work entry_work;		struct delayed_work entry_work;
	unsigned int entry_delay_ms;
			struct mutex avg_mutex;
			struct ewma_psr_time entry_avg_ms;
			struct ewma_psr_time exit_avg_ms;
	};		};

	static void drm_self_refresh_helper_entry_work(struct work_struct *work)		static void drm_self_refresh_helper_entry_work(struct work_struct *work)
	@@ -121,6 +129,44 @@ out_drop_locks:
	drm_modeset_acquire_fini(&ctx);		drm_modeset_acquire_fini(&ctx);
	}		}

			/**
			* drm_self_refresh_helper_update_avg_times - Updates a crtc's SR time averages
			* @state: the state which has just been applied to hardware
			* @commit_time_ms: the amount of time in ms that this commit took to complete
			*
			* Called after &drm_mode_config_funcs.atomic_commit_tail, this function will
			* update the average entry/exit self refresh times on self refresh transitions.
			* These averages will be used when calculating how long to delay before
			* entering self refresh mode after activity.
			*/
			void drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,
			unsigned int commit_time_ms)
			{
			struct drm_crtc *crtc;
			struct drm_crtc_state old_crtc_state, new_crtc_state;
			int i;

			for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
			new_crtc_state, i) {
			struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
			struct ewma_psr_time *time;

			if (old_crtc_state->self_refresh_active ==
			new_crtc_state->self_refresh_active)
			continue;

			if (new_crtc_state->self_refresh_active)
			time = &sr_data->entry_avg_ms;
			else
			time = &sr_data->exit_avg_ms;

			mutex_lock(&sr_data->avg_mutex);
			ewma_psr_time_add(time, commit_time_ms);
			mutex_unlock(&sr_data->avg_mutex);
			}
			}
			EXPORT_SYMBOL(drm_self_refresh_helper_update_avg_times);

	/**		/**
	* drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit		* drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit
	* @state: the state currently being checked		* @state: the state currently being checked
	@@ -152,6 +198,7 @@ void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)

	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {		for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
	struct drm_self_refresh_data *sr_data;		struct drm_self_refresh_data *sr_data;
			unsigned int delay;

	/* Don't trigger the entry timer when we're already in SR */		/* Don't trigger the entry timer when we're already in SR */
	if (crtc_state->self_refresh_active)		if (crtc_state->self_refresh_active)
	@@ -161,8 +208,13 @@ void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)
	if (!sr_data)		if (!sr_data)
	continue;		continue;

			mutex_lock(&sr_data->avg_mutex);
			delay = (ewma_psr_time_read(&sr_data->entry_avg_ms) +
			ewma_psr_time_read(&sr_data->exit_avg_ms)) * 2;
			mutex_unlock(&sr_data->avg_mutex);

	mod_delayed_work(system_wq, &sr_data->entry_work,		mod_delayed_work(system_wq, &sr_data->entry_work,
	msecs_to_jiffies(sr_data->entry_delay_ms));		msecs_to_jiffies(delay));
	}		}
	}		}
	EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);		EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);
	@@ -170,12 +222,10 @@ EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);
	/**		/**
	* drm_self_refresh_helper_init - Initializes self refresh helpers for a crtc		* drm_self_refresh_helper_init - Initializes self refresh helpers for a crtc
	* @crtc: the crtc which supports self refresh supported displays		* @crtc: the crtc which supports self refresh supported displays
	* @entry_delay_ms: amount of inactivity to wait before entering self refresh
	*		*
	* Returns zero if successful or -errno on failure		* Returns zero if successful or -errno on failure
	*/		*/
	int drm_self_refresh_helper_init(struct drm_crtc *crtc,		int drm_self_refresh_helper_init(struct drm_crtc *crtc)
	unsigned int entry_delay_ms)
	{		{
	struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;		struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;

	@@ -189,8 +239,18 @@ int drm_self_refresh_helper_init(struct drm_crtc *crtc,

	INIT_DELAYED_WORK(&sr_data->entry_work,		INIT_DELAYED_WORK(&sr_data->entry_work,
	drm_self_refresh_helper_entry_work);		drm_self_refresh_helper_entry_work);
	sr_data->entry_delay_ms = entry_delay_ms;
	sr_data->crtc = crtc;		sr_data->crtc = crtc;
			mutex_init(&sr_data->avg_mutex);
			ewma_psr_time_init(&sr_data->entry_avg_ms);
			ewma_psr_time_init(&sr_data->exit_avg_ms);

			/*
			* Seed the averages so they're non-zero (and sufficiently large
			* for even poorly performing panels). As time goes on, this will be
			* averaged out and the values will trend to their true value.
			*/
			ewma_psr_time_add(&sr_data->entry_avg_ms, SELF_REFRESH_AVG_SEED_MS);
			ewma_psr_time_add(&sr_data->exit_avg_ms, SELF_REFRESH_AVG_SEED_MS);

	crtc->self_refresh_data = sr_data;		crtc->self_refresh_data = sr_data;
	return 0;		return 0;

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

+1 −4

Original line number	Original line	Diff line number	Diff line
	@@ -39,8 +39,6 @@
	#include "rockchip_drm_vop.h"		#include "rockchip_drm_vop.h"
	#include "rockchip_rgb.h"		#include "rockchip_rgb.h"

	#define VOP_SELF_REFRESH_ENTRY_DELAY_MS 100

	#define VOP_WIN_SET(vop, win, name, v) \		#define VOP_WIN_SET(vop, win, name, v) \
	vop_reg_set(vop, &win->phy->name, win->base, ~0, v, #name)		vop_reg_set(vop, &win->phy->name, win->base, ~0, v, #name)
	#define VOP_SCL_SET(vop, win, name, v) \		#define VOP_SCL_SET(vop, win, name, v) \
	@@ -1563,8 +1561,7 @@ static int vop_create_crtc(struct vop *vop)
	init_completion(&vop->line_flag_completion);		init_completion(&vop->line_flag_completion);
	crtc->port = port;		crtc->port = port;

	ret = drm_self_refresh_helper_init(crtc,		ret = drm_self_refresh_helper_init(crtc);
	VOP_SELF_REFRESH_ENTRY_DELAY_MS);
	if (ret)		if (ret)
	DRM_DEV_DEBUG_KMS(vop->dev,		DRM_DEV_DEBUG_KMS(vop->dev,
	"Failed to init %s with SR helpers %d, ignoring\n",		"Failed to init %s with SR helpers %d, ignoring\n",

include/drm/drm_self_refresh_helper.h

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -12,9 +12,9 @@ struct drm_atomic_state;
	struct drm_crtc;		struct drm_crtc;

	void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state);		void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state);
			void drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,
			unsigned int commit_time_ms);

	int drm_self_refresh_helper_init(struct drm_crtc *crtc,		int drm_self_refresh_helper_init(struct drm_crtc *crtc);
	unsigned int entry_delay_ms);

	void drm_self_refresh_helper_cleanup(struct drm_crtc *crtc);		void drm_self_refresh_helper_cleanup(struct drm_crtc *crtc);
	#endif		#endif

Admin message