drivers/gpu/drm/msm/msm_gpu_devfreq.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2013 Red Hat
   4  * Author: Rob Clark <[email protected]>
   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
  19 static 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 freq
  28          * 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 stash
  38          * 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
  59 static 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 avoid
  65          * confusing devfreq (which is unaware that we are switching
  66          * 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
  77 static 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
 115 static 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
 122 static 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
 130 static void msm_devfreq_boost_work(struct kthread_work *work);
 131 static void msm_devfreq_idle_work(struct kthread_work *work);
 132
 133 static bool has_devfreq(struct msm_gpu *gpu)
 134 {
 135         struct msm_gpu_devfreq *df = &gpu->devfreq;
 136         return !!df->devfreq;
 137 }
 138
 139 void 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         int ret;
 144
 145         /* We need target support to do devfreq */
 146         if (!gpu->funcs->gpu_busy)
 147                 return;
 148
 149         /*
 150          * Setup default values for simple_ondemand governor tuning.  We
 151          * want to throttle up at 50% load for the double-buffer case,
 152          * where due to stalling waiting for vblank we could get stuck
 153          * at (for ex) 30fps at 50% utilization.
 154          */
 155         priv->gpu_devfreq_config.upthreshold = 50;
 156         priv->gpu_devfreq_config.downdifferential = 10;
 157
 158         mutex_init(&df->lock);
 159
 160         ret = dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,
 161                                      DEV_PM_QOS_MIN_FREQUENCY, 0);
 162         if (ret < 0) {
 163                 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize QoS\n");
 164                 return;
 165         }
 166
 167         msm_devfreq_profile.initial_freq = gpu->fast_rate;
 168
 169         /*
 170          * Don't set the freq_table or max_state and let devfreq build the table
 171          * from OPP
 172          * After a deferred probe, these may have be left to non-zero values,
 173          * so set them back to zero before creating the devfreq device
 174          */
 175         msm_devfreq_profile.freq_table = NULL;
 176         msm_devfreq_profile.max_state = 0;
 177
 178         df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev,
 179                         &msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND,
 180                         &priv->gpu_devfreq_config);
 181
 182         if (IS_ERR(df->devfreq)) {
 183                 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n");
 184                 dev_pm_qos_remove_request(&df->boost_freq);
 185                 df->devfreq = NULL;
 186                 return;
 187         }
 188
 189         devfreq_suspend_device(df->devfreq);
 190
 191         gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq);
 192         if (IS_ERR(gpu->cooling)) {
 193                 DRM_DEV_ERROR(&gpu->pdev->dev,
 194                                 "Couldn't register GPU cooling device\n");
 195                 gpu->cooling = NULL;
 196         }
 197
 198         msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work,
 199                               CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 200         msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work,
 201                               CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 202 }
 203
 204 static void cancel_idle_work(struct msm_gpu_devfreq *df)
 205 {
 206         hrtimer_cancel(&df->idle_work.timer);
 207         kthread_cancel_work_sync(&df->idle_work.work);
 208 }
 209
 210 static void cancel_boost_work(struct msm_gpu_devfreq *df)
 211 {
 212         hrtimer_cancel(&df->boost_work.timer);
 213         kthread_cancel_work_sync(&df->boost_work.work);
 214 }
 215
 216 void msm_devfreq_cleanup(struct msm_gpu *gpu)
 217 {
 218         struct msm_gpu_devfreq *df = &gpu->devfreq;
 219
 220         if (!has_devfreq(gpu))
 221                 return;
 222
 223         devfreq_cooling_unregister(gpu->cooling);
 224         dev_pm_qos_remove_request(&df->boost_freq);
 225 }
 226
 227 void msm_devfreq_resume(struct msm_gpu *gpu)
 228 {
 229         struct msm_gpu_devfreq *df = &gpu->devfreq;
 230         unsigned long sample_rate;
 231
 232         if (!has_devfreq(gpu))
 233                 return;
 234
 235         mutex_lock(&df->lock);
 236         df->busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);
 237         df->time = ktime_get();
 238         df->suspended = false;
 239         mutex_unlock(&df->lock);
 240
 241         devfreq_resume_device(df->devfreq);
 242 }
 243
 244 void msm_devfreq_suspend(struct msm_gpu *gpu)
 245 {
 246         struct msm_gpu_devfreq *df = &gpu->devfreq;
 247
 248         if (!has_devfreq(gpu))
 249                 return;
 250
 251         mutex_lock(&df->lock);
 252         df->suspended = true;
 253         mutex_unlock(&df->lock);
 254
 255         devfreq_suspend_device(df->devfreq);
 256
 257         cancel_idle_work(df);
 258         cancel_boost_work(df);
 259 }
 260
 261 static void msm_devfreq_boost_work(struct kthread_work *work)
 262 {
 263         struct msm_gpu_devfreq *df = container_of(work,
 264                         struct msm_gpu_devfreq, boost_work.work);
 265
 266         dev_pm_qos_update_request(&df->boost_freq, 0);
 267 }
 268
 269 void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)
 270 {
 271         struct msm_gpu_devfreq *df = &gpu->devfreq;
 272         uint64_t freq;
 273
 274         if (!has_devfreq(gpu))
 275                 return;
 276
 277         freq = get_freq(gpu);
 278         freq *= factor;
 279
 280         /*
 281          * A nice little trap is that PM QoS operates in terms of KHz,
 282          * while devfreq operates in terms of Hz:
 283          */
 284         do_div(freq, HZ_PER_KHZ);
 285
 286         dev_pm_qos_update_request(&df->boost_freq, freq);
 287
 288         msm_hrtimer_queue_work(&df->boost_work,
 289                                ms_to_ktime(msm_devfreq_profile.polling_ms),
 290                                HRTIMER_MODE_REL);
 291 }
 292
 293 void msm_devfreq_active(struct msm_gpu *gpu)
 294 {
 295         struct msm_gpu_devfreq *df = &gpu->devfreq;
 296         unsigned int idle_time;
 297         unsigned long target_freq;
 298
 299         if (!has_devfreq(gpu))
 300                 return;
 301
 302         /*
 303          * Cancel any pending transition to idle frequency:
 304          */
 305         cancel_idle_work(df);
 306
 307         /*
 308          * Hold devfreq lock to synchronize with get_dev_status()/
 309          * target() callbacks
 310          */
 311         mutex_lock(&df->devfreq->lock);
 312
 313         target_freq = df->idle_freq;
 314
 315         idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time));
 316
 317         df->idle_freq = 0;
 318
 319         /*
 320          * We could have become active again before the idle work had a
 321          * chance to run, in which case the df->idle_freq would have
 322          * still been zero.  In this case, no need to change freq.
 323          */
 324         if (target_freq)
 325                 msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);
 326
 327         mutex_unlock(&df->devfreq->lock);
 328
 329         /*
 330          * If we've been idle for a significant fraction of a polling
 331          * interval, then we won't meet the threshold of busyness for
 332          * the governor to ramp up the freq.. so give some boost
 333          */
 334         if (idle_time > msm_devfreq_profile.polling_ms) {
 335                 msm_devfreq_boost(gpu, 2);
 336         }
 337 }
 338
 339
 340 static void msm_devfreq_idle_work(struct kthread_work *work)
 341 {
 342         struct msm_gpu_devfreq *df = container_of(work,
 343                         struct msm_gpu_devfreq, idle_work.work);
 344         struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);
 345         struct msm_drm_private *priv = gpu->dev->dev_private;
 346         unsigned long idle_freq, target_freq = 0;
 347
 348         /*
 349          * Hold devfreq lock to synchronize with get_dev_status()/
 350          * target() callbacks
 351          */
 352         mutex_lock(&df->devfreq->lock);
 353
 354         idle_freq = get_freq(gpu);
 355
 356         if (priv->gpu_clamp_to_idle)
 357                 msm_devfreq_target(&gpu->pdev->dev, &target_freq, 0);
 358
 359         df->idle_time = ktime_get();
 360         df->idle_freq = idle_freq;
 361
 362         mutex_unlock(&df->devfreq->lock);
 363 }
 364
 365 void msm_devfreq_idle(struct msm_gpu *gpu)
 366 {
 367         struct msm_gpu_devfreq *df = &gpu->devfreq;
 368
 369         if (!has_devfreq(gpu))
 370                 return;
 371
 372         msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),
 373                                HRTIMER_MODE_REL);
 374 }