370 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (C) 2013 Red Hat4 * Author: Rob Clark <robdclark@gmail.com>5 */6 7#include "msm_gpu.h"8#include "msm_gpu_trace.h"9 10#include <linux/devfreq.h>11#include <linux/devfreq_cooling.h>12#include <linux/math64.h>13#include <linux/units.h>14 15/*16 * Power Management:17 */18 19static int msm_devfreq_target(struct device *dev, unsigned long *freq,20 u32 flags)21{22 struct msm_gpu *gpu = dev_to_gpu(dev);23 struct msm_gpu_devfreq *df = &gpu->devfreq;24 struct dev_pm_opp *opp;25 26 /*27 * Note that devfreq_recommended_opp() can modify the freq28 * to something that actually is in the opp table:29 */30 opp = devfreq_recommended_opp(dev, freq, flags);31 if (IS_ERR(opp))32 return PTR_ERR(opp);33 34 trace_msm_gpu_freq_change(dev_pm_opp_get_freq(opp));35 36 /*37 * If the GPU is idle, devfreq is not aware, so just stash38 * the new target freq (to use when we return to active)39 */40 if (df->idle_freq) {41 df->idle_freq = *freq;42 dev_pm_opp_put(opp);43 return 0;44 }45 46 if (gpu->funcs->gpu_set_freq) {47 mutex_lock(&df->lock);48 gpu->funcs->gpu_set_freq(gpu, opp, df->suspended);49 mutex_unlock(&df->lock);50 } else {51 dev_pm_opp_set_rate(dev, *freq);52 }53 54 dev_pm_opp_put(opp);55 56 return 0;57}58 59static unsigned long get_freq(struct msm_gpu *gpu)60{61 struct msm_gpu_devfreq *df = &gpu->devfreq;62 63 /*64 * If the GPU is idle, use the shadow/saved freq to avoid65 * confusing devfreq (which is unaware that we are switching66 * to lowest freq until the device is active again)67 */68 if (df->idle_freq)69 return df->idle_freq;70 71 if (gpu->funcs->gpu_get_freq)72 return gpu->funcs->gpu_get_freq(gpu);73 74 return clk_get_rate(gpu->core_clk);75}76 77static int msm_devfreq_get_dev_status(struct device *dev,78 struct devfreq_dev_status *status)79{80 struct msm_gpu *gpu = dev_to_gpu(dev);81 struct msm_gpu_devfreq *df = &gpu->devfreq;82 u64 busy_cycles, busy_time;83 unsigned long sample_rate;84 ktime_t time;85 86 mutex_lock(&df->lock);87 88 status->current_frequency = get_freq(gpu);89 time = ktime_get();90 status->total_time = ktime_us_delta(time, df->time);91 df->time = time;92 93 if (df->suspended) {94 mutex_unlock(&df->lock);95 status->busy_time = 0;96 return 0;97 }98 99 busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);100 busy_time = busy_cycles - df->busy_cycles;101 df->busy_cycles = busy_cycles;102 103 mutex_unlock(&df->lock);104 105 busy_time *= USEC_PER_SEC;106 busy_time = div64_ul(busy_time, sample_rate);107 if (WARN_ON(busy_time > ~0LU))108 busy_time = ~0LU;109 110 status->busy_time = busy_time;111 112 return 0;113}114 115static int msm_devfreq_get_cur_freq(struct device *dev, unsigned long *freq)116{117 *freq = get_freq(dev_to_gpu(dev));118 119 return 0;120}121 122static struct devfreq_dev_profile msm_devfreq_profile = {123 .timer = DEVFREQ_TIMER_DELAYED,124 .polling_ms = 50,125 .target = msm_devfreq_target,126 .get_dev_status = msm_devfreq_get_dev_status,127 .get_cur_freq = msm_devfreq_get_cur_freq,128};129 130static void msm_devfreq_boost_work(struct kthread_work *work);131static void msm_devfreq_idle_work(struct kthread_work *work);132 133static bool has_devfreq(struct msm_gpu *gpu)134{135 struct msm_gpu_devfreq *df = &gpu->devfreq;136 return !!df->devfreq;137}138 139void msm_devfreq_init(struct msm_gpu *gpu)140{141 struct msm_gpu_devfreq *df = &gpu->devfreq;142 struct msm_drm_private *priv = gpu->dev->dev_private;143 144 /* We need target support to do devfreq */145 if (!gpu->funcs->gpu_busy)146 return;147 148 /*149 * Setup default values for simple_ondemand governor tuning. We150 * want to throttle up at 50% load for the double-buffer case,151 * where due to stalling waiting for vblank we could get stuck152 * at (for ex) 30fps at 50% utilization.153 */154 priv->gpu_devfreq_config.upthreshold = 50;155 priv->gpu_devfreq_config.downdifferential = 10;156 157 mutex_init(&df->lock);158 159 dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,160 DEV_PM_QOS_MIN_FREQUENCY, 0);161 162 msm_devfreq_profile.initial_freq = gpu->fast_rate;163 164 /*165 * Don't set the freq_table or max_state and let devfreq build the table166 * from OPP167 * After a deferred probe, these may have be left to non-zero values,168 * so set them back to zero before creating the devfreq device169 */170 msm_devfreq_profile.freq_table = NULL;171 msm_devfreq_profile.max_state = 0;172 173 df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev,174 &msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND,175 &priv->gpu_devfreq_config);176 177 if (IS_ERR(df->devfreq)) {178 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n");179 dev_pm_qos_remove_request(&df->boost_freq);180 df->devfreq = NULL;181 return;182 }183 184 devfreq_suspend_device(df->devfreq);185 186 gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq);187 if (IS_ERR(gpu->cooling)) {188 DRM_DEV_ERROR(&gpu->pdev->dev,189 "Couldn't register GPU cooling device\n");190 gpu->cooling = NULL;191 }192 193 msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work,194 CLOCK_MONOTONIC, HRTIMER_MODE_REL);195 msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work,196 CLOCK_MONOTONIC, HRTIMER_MODE_REL);197}198 199static void cancel_idle_work(struct msm_gpu_devfreq *df)200{201 hrtimer_cancel(&df->idle_work.timer);202 kthread_cancel_work_sync(&df->idle_work.work);203}204 205static void cancel_boost_work(struct msm_gpu_devfreq *df)206{207 hrtimer_cancel(&df->boost_work.timer);208 kthread_cancel_work_sync(&df->boost_work.work);209}210 211void msm_devfreq_cleanup(struct msm_gpu *gpu)212{213 struct msm_gpu_devfreq *df = &gpu->devfreq;214 215 if (!has_devfreq(gpu))216 return;217 218 devfreq_cooling_unregister(gpu->cooling);219 dev_pm_qos_remove_request(&df->boost_freq);220}221 222void msm_devfreq_resume(struct msm_gpu *gpu)223{224 struct msm_gpu_devfreq *df = &gpu->devfreq;225 unsigned long sample_rate;226 227 if (!has_devfreq(gpu))228 return;229 230 mutex_lock(&df->lock);231 df->busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);232 df->time = ktime_get();233 df->suspended = false;234 mutex_unlock(&df->lock);235 236 devfreq_resume_device(df->devfreq);237}238 239void msm_devfreq_suspend(struct msm_gpu *gpu)240{241 struct msm_gpu_devfreq *df = &gpu->devfreq;242 243 if (!has_devfreq(gpu))244 return;245 246 mutex_lock(&df->lock);247 df->suspended = true;248 mutex_unlock(&df->lock);249 250 devfreq_suspend_device(df->devfreq);251 252 cancel_idle_work(df);253 cancel_boost_work(df);254}255 256static void msm_devfreq_boost_work(struct kthread_work *work)257{258 struct msm_gpu_devfreq *df = container_of(work,259 struct msm_gpu_devfreq, boost_work.work);260 261 dev_pm_qos_update_request(&df->boost_freq, 0);262}263 264void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)265{266 struct msm_gpu_devfreq *df = &gpu->devfreq;267 uint64_t freq;268 269 if (!has_devfreq(gpu))270 return;271 272 freq = get_freq(gpu);273 freq *= factor;274 275 /*276 * A nice little trap is that PM QoS operates in terms of KHz,277 * while devfreq operates in terms of Hz:278 */279 do_div(freq, HZ_PER_KHZ);280 281 dev_pm_qos_update_request(&df->boost_freq, freq);282 283 msm_hrtimer_queue_work(&df->boost_work,284 ms_to_ktime(msm_devfreq_profile.polling_ms),285 HRTIMER_MODE_REL);286}287 288void msm_devfreq_active(struct msm_gpu *gpu)289{290 struct msm_gpu_devfreq *df = &gpu->devfreq;291 unsigned int idle_time;292 unsigned long target_freq;293 294 if (!has_devfreq(gpu))295 return;296 297 /*298 * Cancel any pending transition to idle frequency:299 */300 cancel_idle_work(df);301 302 /*303 * Hold devfreq lock to synchronize with get_dev_status()/304 * target() callbacks305 */306 mutex_lock(&df->devfreq->lock);307 308 target_freq = df->idle_freq;309 310 idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time));311 312 df->idle_freq = 0;313 314 /*315 * We could have become active again before the idle work had a316 * chance to run, in which case the df->idle_freq would have317 * still been zero. In this case, no need to change freq.318 */319 if (target_freq)320 msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);321 322 mutex_unlock(&df->devfreq->lock);323 324 /*325 * If we've been idle for a significant fraction of a polling326 * interval, then we won't meet the threshold of busyness for327 * the governor to ramp up the freq.. so give some boost328 */329 if (idle_time > msm_devfreq_profile.polling_ms) {330 msm_devfreq_boost(gpu, 2);331 }332}333 334 335static void msm_devfreq_idle_work(struct kthread_work *work)336{337 struct msm_gpu_devfreq *df = container_of(work,338 struct msm_gpu_devfreq, idle_work.work);339 struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);340 struct msm_drm_private *priv = gpu->dev->dev_private;341 unsigned long idle_freq, target_freq = 0;342 343 /*344 * Hold devfreq lock to synchronize with get_dev_status()/345 * target() callbacks346 */347 mutex_lock(&df->devfreq->lock);348 349 idle_freq = get_freq(gpu);350 351 if (priv->gpu_clamp_to_idle)352 msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);353 354 df->idle_time = ktime_get();355 df->idle_freq = idle_freq;356 357 mutex_unlock(&df->devfreq->lock);358}359 360void msm_devfreq_idle(struct msm_gpu *gpu)361{362 struct msm_gpu_devfreq *df = &gpu->devfreq;363 364 if (!has_devfreq(gpu))365 return;366 367 msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),368 HRTIMER_MODE_REL);369}370