// SPDX-License-Identifier: GPL-2.0-only/* * Copyright (C) 2013 Red Hat * Author: Rob Clark <robdclark@gmail.com> */ #include "msm_gpu.h"#include "msm_gpu_trace.h" #include <linux/devfreq.h>#include <linux/devfreq_cooling.h>#include <linux/math64.h>#include <linux/units.h> /* * Power Management: */ static int msm_devfreq_target(struct device *dev, unsigned long *freq,		u32 flags){	struct msm_gpu *gpu = dev_to_gpu(dev);	struct msm_gpu_devfreq *df = &gpu->devfreq;	struct dev_pm_opp *opp; 	/*	 * Note that devfreq_recommended_opp() can modify the freq	 * to something that actually is in the opp table:	 */	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);		return 0;	} 	if (gpu->funcs->gpu_set_freq) {		mutex_lock(&df->lock);		gpu->funcs->gpu_set_freq(gpu, opp, df->suspended);		mutex_unlock(&df->lock);	} else {		dev_pm_opp_set_rate(dev, *freq);	} 	dev_pm_opp_put(opp); 	return 0;} 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); 	return clk_get_rate(gpu->core_clk);} static int msm_devfreq_get_dev_status(struct device *dev,		struct devfreq_dev_status *status){	struct msm_gpu *gpu = dev_to_gpu(dev);	struct msm_gpu_devfreq *df = &gpu->devfreq;	u64 busy_cycles, busy_time;	unsigned long sample_rate;	ktime_t time; 	mutex_lock(&df->lock); 	status->current_frequency = get_freq(gpu);	time = ktime_get();	status->total_time = ktime_us_delta(time, df->time);	df->time = time; 	if (df->suspended) {		mutex_unlock(&df->lock);		status->busy_time = 0;		return 0;	} 	busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);	busy_time = busy_cycles - df->busy_cycles;	df->busy_cycles = busy_cycles; 	mutex_unlock(&df->lock); 	busy_time *= USEC_PER_SEC;	busy_time = div64_ul(busy_time, sample_rate);	if (WARN_ON(busy_time > ~0LU))		busy_time = ~0LU; 	status->busy_time = busy_time; 	return 0;} static int msm_devfreq_get_cur_freq(struct device *dev, unsigned long *freq){	*freq = get_freq(dev_to_gpu(dev)); 	return 0;} static struct devfreq_dev_profile msm_devfreq_profile = {	.timer = DEVFREQ_TIMER_DELAYED,	.polling_ms = 50,	.target = msm_devfreq_target,	.get_dev_status = msm_devfreq_get_dev_status,	.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;	return !!df->devfreq;} void msm_devfreq_init(struct msm_gpu *gpu){	struct msm_gpu_devfreq *df = &gpu->devfreq;	struct msm_drm_private *priv = gpu->dev->dev_private;	int ret; 	/* We need target support to do devfreq */	if (!gpu->funcs->gpu_busy)		return; 	/*	 * Setup default values for simple_ondemand governor tuning.  We	 * want to throttle up at 50% load for the double-buffer case,	 * where due to stalling waiting for vblank we could get stuck	 * at (for ex) 30fps at 50% utilization.	 */	priv->gpu_devfreq_config.upthreshold = 50;	priv->gpu_devfreq_config.downdifferential = 10; 	mutex_init(&df->lock);	df->suspended = true; 	ret = dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,				     DEV_PM_QOS_MIN_FREQUENCY, 0);	if (ret < 0) {		DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize QoS\n");		return;	} 	msm_devfreq_profile.initial_freq = gpu->fast_rate; 	/*	 * Don't set the freq_table or max_state and let devfreq build the table	 * from OPP	 * After a deferred probe, these may have be left to non-zero values,	 * so set them back to zero before creating the devfreq device	 */	msm_devfreq_profile.freq_table = NULL;	msm_devfreq_profile.max_state = 0; 	df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev,			&msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND,			&priv->gpu_devfreq_config); 	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;	} 	devfreq_suspend_device(df->devfreq); 	gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq);	if (IS_ERR(gpu->cooling)) {		DRM_DEV_ERROR(&gpu->pdev->dev,				"Couldn't register GPU cooling device\n");		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){	struct msm_gpu_devfreq *df = &gpu->devfreq; 	if (!has_devfreq(gpu))		return; 	devfreq_cooling_unregister(gpu->cooling);	dev_pm_qos_remove_request(&df->boost_freq);} void msm_devfreq_resume(struct msm_gpu *gpu){	struct msm_gpu_devfreq *df = &gpu->devfreq;	unsigned long sample_rate; 	if (!has_devfreq(gpu))		return; 	mutex_lock(&df->lock);	df->busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);	df->time = ktime_get();	df->suspended = false;	mutex_unlock(&df->lock); 	devfreq_resume_device(df->devfreq);} void msm_devfreq_suspend(struct msm_gpu *gpu){	struct msm_gpu_devfreq *df = &gpu->devfreq; 	if (!has_devfreq(gpu))		return; 	mutex_lock(&df->lock);	df->suspended = true;	mutex_unlock(&df->lock); 	devfreq_suspend_device(df->devfreq); 	cancel_idle_work(df);	cancel_boost_work(df);} 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);}