revert msm_gpu_devfreq to something simple

Signed-off-by: Christoph Rudorff <[email protected]>

Author: Christoph Rudorff

drivers/gpu/drm/msm/msm_fence.c

@@ -35,7 +35,6 @@ static void deadline_work(struct kthread_work *work)
 	if (msm_fence_completed(fctx, fctx->next_deadline_fence))
 		return;
 
-	msm_devfreq_boost(fctx2gpu(fctx), 2);
 }
 
 

drivers/gpu/drm/msm/msm_gpu.c

@@ -68,7 +68,6 @@ static int enable_clk(struct msm_gpu *gpu)
 
 	if (gpu->core_clk && gpu->fast_rate)
 		dev_pm_opp_set_rate(&gpu->pdev->dev, gpu->fast_rate);
-
 	*/
 
 	/* Set the RBBM timer rate to 19.2Mhz */
@@ -115,6 +114,7 @@ int msm_gpu_pm_resume(struct msm_gpu *gpu)
 	int ret;
 
 	DBG("%s", gpu->name);
+	dev_dbg(&gpu->pdev->dev, "%s\n", __func__);
 	trace_msm_gpu_resume(0);
 
 	ret = enable_pwrrail(gpu);
@@ -132,6 +132,7 @@ int msm_gpu_pm_resume(struct msm_gpu *gpu)
 	msm_devfreq_resume(gpu);
 
 	gpu->needs_hw_init = true;
+	dev_dbg(&gpu->pdev->dev, "%s done\n", __func__);
 
 	return 0;
 }
@@ -141,6 +142,7 @@ int msm_gpu_pm_suspend(struct msm_gpu *gpu)
 	int ret;
 
 	DBG("%s", gpu->name);
+	dev_dbg(&gpu->pdev->dev, "%s\n", __func__);
 	trace_msm_gpu_suspend(0);
 
 	msm_devfreq_suspend(gpu);
@@ -158,6 +160,7 @@ int msm_gpu_pm_suspend(struct msm_gpu *gpu)
 		return ret;
 
 	gpu->suspend_count++;
+	dev_dbg(&gpu->pdev->dev, "%s done\n", __func__);
 
 	return 0;
 }
@@ -696,7 +699,6 @@ static void retire_submit(struct msm_gpu *gpu, struct msm_ringbuffer *ring,
 	gpu->active_submits--;
 	WARN_ON(gpu->active_submits < 0);
 	if (!gpu->active_submits) {
-		msm_devfreq_idle(gpu);
 		pm_runtime_put_autosuspend(&gpu->pdev->dev);
 	}
 
@@ -785,7 +787,6 @@ void msm_gpu_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit)
 	mutex_lock(&gpu->active_lock);
 	if (!gpu->active_submits) {
 		pm_runtime_get(&gpu->pdev->dev);
-		msm_devfreq_active(gpu);
 	}
 	gpu->active_submits++;
 	mutex_unlock(&gpu->active_lock);

drivers/gpu/drm/msm/msm_gpu.h

@@ -113,25 +113,6 @@ struct msm_gpu_devfreq {
 	/** lock: lock for "suspended", "busy_cycles", and "time" */
 	struct mutex lock;
 
-	/**
-	 * idle_freq:
-	 *
-	 * Shadow frequency used while the GPU is idle.  From the PoV of
-	 * the devfreq governor, we are continuing to sample busyness and
-	 * adjust frequency while the GPU is idle, but we use this shadow
-	 * value as the GPU is actually clamped to minimum frequency while
-	 * it is inactive.
-	 */
-	unsigned long idle_freq;
-
-	/**
-	 * boost_constraint:
-	 *
-	 * A PM QoS constraint to boost min freq for a period of time
-	 * until the boost expires.
-	 */
-	struct dev_pm_qos_request boost_freq;
-
 	/**
 	 * busy_cycles: Last busy counter value, for calculating elapsed busy
 	 * cycles since last sampling period.
@@ -141,24 +122,6 @@ struct msm_gpu_devfreq {
 	/** time: Time of last sampling period. */
 	ktime_t time;
 
-	/** idle_time: Time of last transition to idle: */
-	ktime_t idle_time;
-
-	/**
-	 * idle_work:
-	 *
-	 * Used to delay clamping to idle freq on active->idle transition.
-	 */
-	struct msm_hrtimer_work idle_work;
-
-	/**
-	 * boost_work:
-	 *
-	 * Used to reset the boost_constraint after the boost period has
-	 * elapsed
-	 */
-	struct msm_hrtimer_work boost_work;
-
 	/** suspended: tracks if we're suspended */
 	bool suspended;
 };
@@ -638,9 +601,6 @@ void msm_devfreq_init(struct msm_gpu *gpu);
 void msm_devfreq_cleanup(struct msm_gpu *gpu);
 void msm_devfreq_resume(struct msm_gpu *gpu);
 void msm_devfreq_suspend(struct msm_gpu *gpu);
-void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor);
-void msm_devfreq_active(struct msm_gpu *gpu);
-void msm_devfreq_idle(struct msm_gpu *gpu);
 
 int msm_gpu_hw_init(struct msm_gpu *gpu);
 

drivers/gpu/drm/msm/msm_gpu_devfreq.c

@@ -15,6 +15,7 @@
 /*
  * Power Management:
  */
+static unsigned long get_freq(struct msm_gpu *gpu);
 
 static int msm_devfreq_target(struct device *dev, unsigned long *freq,
 		u32 flags)
@@ -23,25 +24,30 @@ static int msm_devfreq_target(struct device *dev, unsigned long *freq,
 	struct msm_gpu_devfreq *df = &gpu->devfreq;
 	struct dev_pm_opp *opp;
 
+	// opp-suspend kacke ....
+	if (df->suspended)
+		dev_err(dev, "%s while suspended ??\n", __func__);
+
+	unsigned long curr_freq = get_freq(gpu);
+	if (*freq == curr_freq)
+		return 0;
+
 	/*
 	 * Note that devfreq_recommended_opp() can modify the freq
 	 * to something that actually is in the opp table:
 	 */
+	unsigned long fff = *freq;
 	opp = devfreq_recommended_opp(dev, freq, flags);
 	if (IS_ERR(opp))
 		return PTR_ERR(opp);
 
-	trace_msm_gpu_freq_change(dev_pm_opp_get_freq(opp));
 
-	/*
-	 * If the GPU is idle, devfreq is not aware, so just stash
-	 * the new target freq (to use when we return to active)
-	 */
-	if (df->idle_freq) {
-		df->idle_freq = *freq;
-		dev_pm_opp_put(opp);
+	if (*freq == curr_freq)
 		return 0;
-	}
+
+	dev_dbg(dev, "%s %lu => %lu (%lu)\n", __func__, get_freq(gpu), *freq, fff);
+
+	trace_msm_gpu_freq_change(dev_pm_opp_get_freq(opp));
 
 	if (gpu->funcs->gpu_set_freq) {
 		mutex_lock(&df->lock);
@@ -58,16 +64,6 @@ static int msm_devfreq_target(struct device *dev, unsigned long *freq,
 
 static unsigned long get_freq(struct msm_gpu *gpu)
 {
-	struct msm_gpu_devfreq *df = &gpu->devfreq;
-
-	/*
-	 * If the GPU is idle, use the shadow/saved freq to avoid
-	 * confusing devfreq (which is unaware that we are switching
-	 * to lowest freq until the device is active again)
-	 */
-	if (df->idle_freq)
-		return df->idle_freq;
-
 	if (gpu->funcs->gpu_get_freq)
 		return gpu->funcs->gpu_get_freq(gpu);
 
@@ -136,9 +132,6 @@ static struct devfreq_dev_profile msm_devfreq_profile = {
 	.get_cur_freq = msm_devfreq_get_cur_freq,
 };
 
-static void msm_devfreq_boost_work(struct kthread_work *work);
-static void msm_devfreq_idle_work(struct kthread_work *work);
-
 static bool has_devfreq(struct msm_gpu *gpu)
 {
 	struct msm_gpu_devfreq *df = &gpu->devfreq;
@@ -165,9 +158,6 @@ void msm_devfreq_init(struct msm_gpu *gpu)
 
 	mutex_init(&df->lock);
 
-	dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,
-			       DEV_PM_QOS_MIN_FREQUENCY, 0);
-
 	msm_devfreq_profile.initial_freq = gpu->fast_rate;
 
 	/*
@@ -185,7 +175,6 @@ void msm_devfreq_init(struct msm_gpu *gpu)
 
 	if (IS_ERR(df->devfreq)) {
 		DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n");
-		dev_pm_qos_remove_request(&df->boost_freq);
 		df->devfreq = NULL;
 		return;
 	}
@@ -199,22 +188,6 @@ void msm_devfreq_init(struct msm_gpu *gpu)
 		gpu->cooling = NULL;
 	}
 
-	msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work,
-			      CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-	msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work,
-			      CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-}
-
-static void cancel_idle_work(struct msm_gpu_devfreq *df)
-{
-	hrtimer_cancel(&df->idle_work.timer);
-	kthread_cancel_work_sync(&df->idle_work.work);
-}
-
-static void cancel_boost_work(struct msm_gpu_devfreq *df)
-{
-	hrtimer_cancel(&df->boost_work.timer);
-	kthread_cancel_work_sync(&df->boost_work.work);
 }
 
 void msm_devfreq_cleanup(struct msm_gpu *gpu)
@@ -224,8 +197,8 @@ void msm_devfreq_cleanup(struct msm_gpu *gpu)
 	if (!has_devfreq(gpu))
 		return;
 
+	devm_devfreq_remove_device(&gpu->pdev->dev, df->devfreq);
 	devfreq_cooling_unregister(gpu->cooling);
-	dev_pm_qos_remove_request(&df->boost_freq);
 }
 
 void msm_devfreq_resume(struct msm_gpu *gpu)
@@ -239,7 +212,6 @@ void msm_devfreq_resume(struct msm_gpu *gpu)
 	mutex_lock(&df->lock);
 	df->busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);
 	df->time = ktime_get();
-	df->idle_freq = 0;
 	df->suspended = false;
 	mutex_unlock(&df->lock);
 
@@ -257,123 +229,6 @@ void msm_devfreq_suspend(struct msm_gpu *gpu)
 	df->suspended = true;
 	mutex_unlock(&df->lock);
 
-	cancel_idle_work(df);
-	cancel_boost_work(df);
-
 	devfreq_suspend_device(df->devfreq);
 }
 
-static void msm_devfreq_boost_work(struct kthread_work *work)
-{
-	struct msm_gpu_devfreq *df = container_of(work,
-			struct msm_gpu_devfreq, boost_work.work);
-
-	dev_pm_qos_update_request(&df->boost_freq, 0);
-}
-
-void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)
-{
-	struct msm_gpu_devfreq *df = &gpu->devfreq;
-	uint64_t freq;
-
-	if (!has_devfreq(gpu))
-		return;
-
-	freq = get_freq(gpu);
-	freq *= factor;
-
-	/*
-	 * A nice little trap is that PM QoS operates in terms of KHz,
-	 * while devfreq operates in terms of Hz:
-	 */
-	do_div(freq, HZ_PER_KHZ);
-
-	dev_pm_qos_update_request(&df->boost_freq, freq);
-
-	msm_hrtimer_queue_work(&df->boost_work,
-			       ms_to_ktime(msm_devfreq_profile.polling_ms),
-			       HRTIMER_MODE_REL);
-}
-
-void msm_devfreq_active(struct msm_gpu *gpu)
-{
-	struct msm_gpu_devfreq *df = &gpu->devfreq;
-	unsigned int idle_time;
-	unsigned long target_freq;
-
-	if (!has_devfreq(gpu))
-		return;
-
-	/*
-	 * Cancel any pending transition to idle frequency:
-	 */
-	cancel_idle_work(df);
-
-	/*
-	 * Hold devfreq lock to synchronize with get_dev_status()/
-	 * target() callbacks
-	 */
-	mutex_lock(&df->devfreq->lock);
-
-	target_freq = df->idle_freq;
-
-	idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time));
-
-	df->idle_freq = 0;
-
-	/*
-	 * We could have become active again before the idle work had a
-	 * chance to run, in which case the df->idle_freq would have
-	 * still been zero.  In this case, no need to change freq.
-	 */
-	if (target_freq)
-		msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);
-
-	mutex_unlock(&df->devfreq->lock);
-
-	/*
-	 * If we've been idle for a significant fraction of a polling
-	 * interval, then we won't meet the threshold of busyness for
-	 * the governor to ramp up the freq.. so give some boost
-	 */
-	if (idle_time > msm_devfreq_profile.polling_ms) {
-		msm_devfreq_boost(gpu, 2);
-	}
-}
-
-
-static void msm_devfreq_idle_work(struct kthread_work *work)
-{
-	struct msm_gpu_devfreq *df = container_of(work,
-			struct msm_gpu_devfreq, idle_work.work);
-	struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);
-	struct msm_drm_private *priv = gpu->dev->dev_private;
-	unsigned long idle_freq, target_freq = 0;
-
-	/*
-	 * Hold devfreq lock to synchronize with get_dev_status()/
-	 * target() callbacks
-	 */
-	mutex_lock(&df->devfreq->lock);
-
-	idle_freq = get_freq(gpu);
-
-	if (priv->gpu_clamp_to_idle)
-		msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);
-
-	df->idle_time = ktime_get();
-	df->idle_freq = idle_freq;
-
-	mutex_unlock(&df->devfreq->lock);
-}
-
-void msm_devfreq_idle(struct msm_gpu *gpu)
-{
-	struct msm_gpu_devfreq *df = &gpu->devfreq;
-
-	if (!has_devfreq(gpu))
-		return;
-
-	msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),
-			       HRTIMER_MODE_REL);
-}