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         if (gpu->funcs->gpu_set_freq) {
  37                 mutex_lock(&df->lock);
  38                 gpu->funcs->gpu_set_freq(gpu, opp, df->suspended);
  39                 mutex_unlock(&df->lock);
  40         } else {
  41                 clk_set_rate(gpu->core_clk, *freq);
  42         }
  43
  44         dev_pm_opp_put(opp);
  45
  46         return 0;
  47 }
  48
  49 static unsigned long get_freq(struct msm_gpu *gpu)
  50 {
  51         if (gpu->funcs->gpu_get_freq)
  52                 return gpu->funcs->gpu_get_freq(gpu);
  53
  54         return clk_get_rate(gpu->core_clk);
  55 }
  56
  57 static void get_raw_dev_status(struct msm_gpu *gpu,
  58                 struct devfreq_dev_status *status)
  59 {
  60         struct msm_gpu_devfreq *df = &gpu->devfreq;
  61         u64 busy_cycles, busy_time;
  62         unsigned long sample_rate;
  63         ktime_t time;
  64
  65         mutex_lock(&df->lock);
  66
  67         status->current_frequency = get_freq(gpu);
  68         time = ktime_get();
  69         status->total_time = ktime_us_delta(time, df->time);
  70         df->time = time;
  71
  72         if (df->suspended) {
  73                 mutex_unlock(&df->lock);
  74                 status->busy_time = 0;
  75                 return;
  76         }
  77
  78         busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);
  79         busy_time = busy_cycles - df->busy_cycles;
  80         df->busy_cycles = busy_cycles;
  81
  82         mutex_unlock(&df->lock);
  83
  84         busy_time *= USEC_PER_SEC;
  85         busy_time = div64_ul(busy_time, sample_rate);
  86         if (WARN_ON(busy_time > ~0LU))
  87                 busy_time = ~0LU;
  88
  89         status->busy_time = busy_time;
  90 }
  91
  92 static void update_average_dev_status(struct msm_gpu *gpu,
  93                 const struct devfreq_dev_status *raw)
  94 {
  95         struct msm_gpu_devfreq *df = &gpu->devfreq;
  96         const u32 polling_ms = df->devfreq->profile->polling_ms;
  97         const u32 max_history_ms = polling_ms * 11 / 10;
  98         struct devfreq_dev_status *avg = &df->average_status;
  99         u64 avg_freq;
 100
 101         /* simple_ondemand governor interacts poorly with gpu->clamp_to_idle.
 102          * When we enforce the constraint on idle, it calls get_dev_status
 103          * which would normally reset the stats.  When we remove the
 104          * constraint on active, it calls get_dev_status again where busy_time
 105          * would be 0.
 106          *
 107          * To remedy this, we always return the average load over the past
 108          * polling_ms.
 109          */
 110
 111         /* raw is longer than polling_ms or avg has no history */
 112         if (div_u64(raw->total_time, USEC_PER_MSEC) >= polling_ms ||
 113             !avg->total_time) {
 114                 *avg = *raw;
 115                 return;
 116         }
 117
 118         /* Truncate the oldest history first.
 119          *
 120          * Because we keep the history with a single devfreq_dev_status,
 121          * rather than a list of devfreq_dev_status, we have to assume freq
 122          * and load are the same over avg->total_time.  We can scale down
 123          * avg->busy_time and avg->total_time by the same factor to drop
 124          * history.
 125          */
 126         if (div_u64(avg->total_time + raw->total_time, USEC_PER_MSEC) >=
 127                         max_history_ms) {
 128                 const u32 new_total_time = polling_ms * USEC_PER_MSEC -
 129                         raw->total_time;
 130                 avg->busy_time = div_u64(
 131                                 mul_u32_u32(avg->busy_time, new_total_time),
 132                                 avg->total_time);
 133                 avg->total_time = new_total_time;
 134         }
 135
 136         /* compute the average freq over avg->total_time + raw->total_time */
 137         avg_freq = mul_u32_u32(avg->current_frequency, avg->total_time);
 138         avg_freq += mul_u32_u32(raw->current_frequency, raw->total_time);
 139         do_div(avg_freq, avg->total_time + raw->total_time);
 140
 141         avg->current_frequency = avg_freq;
 142         avg->busy_time += raw->busy_time;
 143         avg->total_time += raw->total_time;
 144 }
 145
 146 static int msm_devfreq_get_dev_status(struct device *dev,
 147                 struct devfreq_dev_status *status)
 148 {
 149         struct msm_gpu *gpu = dev_to_gpu(dev);
 150         struct devfreq_dev_status raw;
 151
 152         get_raw_dev_status(gpu, &raw);
 153         update_average_dev_status(gpu, &raw);
 154         *status = gpu->devfreq.average_status;
 155
 156         return 0;
 157 }
 158
 159 static int msm_devfreq_get_cur_freq(struct device *dev, unsigned long *freq)
 160 {
 161         *freq = get_freq(dev_to_gpu(dev));
 162
 163         return 0;
 164 }
 165
 166 static struct devfreq_dev_profile msm_devfreq_profile = {
 167         .timer = DEVFREQ_TIMER_DELAYED,
 168         .polling_ms = 50,
 169         .target = msm_devfreq_target,
 170         .get_dev_status = msm_devfreq_get_dev_status,
 171         .get_cur_freq = msm_devfreq_get_cur_freq,
 172 };
 173
 174 static void msm_devfreq_boost_work(struct kthread_work *work);
 175 static void msm_devfreq_idle_work(struct kthread_work *work);
 176
 177 static bool has_devfreq(struct msm_gpu *gpu)
 178 {
 179         struct msm_gpu_devfreq *df = &gpu->devfreq;
 180         return !!df->devfreq;
 181 }
 182
 183 void msm_devfreq_init(struct msm_gpu *gpu)
 184 {
 185         struct msm_gpu_devfreq *df = &gpu->devfreq;
 186
 187         /* We need target support to do devfreq */
 188         if (!gpu->funcs->gpu_busy)
 189                 return;
 190
 191         mutex_init(&df->lock);
 192
 193         dev_pm_qos_add_request(&gpu->pdev->dev, &df->idle_freq,
 194                                DEV_PM_QOS_MAX_FREQUENCY,
 195                                PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
 196         dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,
 197                                DEV_PM_QOS_MIN_FREQUENCY, 0);
 198
 199         msm_devfreq_profile.initial_freq = gpu->fast_rate;
 200
 201         /*
 202          * Don't set the freq_table or max_state and let devfreq build the table
 203          * from OPP
 204          * After a deferred probe, these may have be left to non-zero values,
 205          * so set them back to zero before creating the devfreq device
 206          */
 207         msm_devfreq_profile.freq_table = NULL;
 208         msm_devfreq_profile.max_state = 0;
 209
 210         df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev,
 211                         &msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND,
 212                         NULL);
 213
 214         if (IS_ERR(df->devfreq)) {
 215                 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n");
 216                 dev_pm_qos_remove_request(&df->idle_freq);
 217                 dev_pm_qos_remove_request(&df->boost_freq);
 218                 df->devfreq = NULL;
 219                 return;
 220         }
 221
 222         devfreq_suspend_device(df->devfreq);
 223
 224         gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq);
 225         if (IS_ERR(gpu->cooling)) {
 226                 DRM_DEV_ERROR(&gpu->pdev->dev,
 227                                 "Couldn't register GPU cooling device\n");
 228                 gpu->cooling = NULL;
 229         }
 230
 231         msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work,
 232                               CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 233         msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work,
 234                               CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 235 }
 236
 237 static void cancel_idle_work(struct msm_gpu_devfreq *df)
 238 {
 239         hrtimer_cancel(&df->idle_work.timer);
 240         kthread_cancel_work_sync(&df->idle_work.work);
 241 }
 242
 243 static void cancel_boost_work(struct msm_gpu_devfreq *df)
 244 {
 245         hrtimer_cancel(&df->boost_work.timer);
 246         kthread_cancel_work_sync(&df->boost_work.work);
 247 }
 248
 249 void msm_devfreq_cleanup(struct msm_gpu *gpu)
 250 {
 251         struct msm_gpu_devfreq *df = &gpu->devfreq;
 252
 253         if (!has_devfreq(gpu))
 254                 return;
 255
 256         devfreq_cooling_unregister(gpu->cooling);
 257         dev_pm_qos_remove_request(&df->boost_freq);
 258         dev_pm_qos_remove_request(&df->idle_freq);
 259 }
 260
 261 void msm_devfreq_resume(struct msm_gpu *gpu)
 262 {
 263         struct msm_gpu_devfreq *df = &gpu->devfreq;
 264         unsigned long sample_rate;
 265
 266         if (!has_devfreq(gpu))
 267                 return;
 268
 269         mutex_lock(&df->lock);
 270         df->busy_cycles = gpu->funcs->gpu_busy(gpu, &sample_rate);
 271         df->time = ktime_get();
 272         df->suspended = false;
 273         mutex_unlock(&df->lock);
 274
 275         devfreq_resume_device(df->devfreq);
 276 }
 277
 278 void msm_devfreq_suspend(struct msm_gpu *gpu)
 279 {
 280         struct msm_gpu_devfreq *df = &gpu->devfreq;
 281
 282         if (!has_devfreq(gpu))
 283                 return;
 284
 285         mutex_lock(&df->lock);
 286         df->suspended = true;
 287         mutex_unlock(&df->lock);
 288
 289         devfreq_suspend_device(df->devfreq);
 290
 291         cancel_idle_work(df);
 292         cancel_boost_work(df);
 293 }
 294
 295 static void msm_devfreq_boost_work(struct kthread_work *work)
 296 {
 297         struct msm_gpu_devfreq *df = container_of(work,
 298                         struct msm_gpu_devfreq, boost_work.work);
 299
 300         dev_pm_qos_update_request(&df->boost_freq, 0);
 301 }
 302
 303 void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)
 304 {
 305         struct msm_gpu_devfreq *df = &gpu->devfreq;
 306         uint64_t freq;
 307
 308         if (!has_devfreq(gpu))
 309                 return;
 310
 311         freq = get_freq(gpu);
 312         freq *= factor;
 313
 314         /*
 315          * A nice little trap is that PM QoS operates in terms of KHz,
 316          * while devfreq operates in terms of Hz:
 317          */
 318         do_div(freq, HZ_PER_KHZ);
 319
 320         dev_pm_qos_update_request(&df->boost_freq, freq);
 321
 322         msm_hrtimer_queue_work(&df->boost_work,
 323                                ms_to_ktime(msm_devfreq_profile.polling_ms),
 324                                HRTIMER_MODE_REL);
 325 }
 326
 327 void msm_devfreq_active(struct msm_gpu *gpu)
 328 {
 329         struct msm_gpu_devfreq *df = &gpu->devfreq;
 330         unsigned int idle_time;
 331
 332         if (!has_devfreq(gpu))
 333                 return;
 334
 335         /*
 336          * Cancel any pending transition to idle frequency:
 337          */
 338         cancel_idle_work(df);
 339
 340         idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time));
 341
 342         /*
 343          * If we've been idle for a significant fraction of a polling
 344          * interval, then we won't meet the threshold of busyness for
 345          * the governor to ramp up the freq.. so give some boost
 346          */
 347         if (idle_time > msm_devfreq_profile.polling_ms) {
 348                 msm_devfreq_boost(gpu, 2);
 349         }
 350
 351         dev_pm_qos_update_request(&df->idle_freq,
 352                                   PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
 353 }
 354
 355
 356 static void msm_devfreq_idle_work(struct kthread_work *work)
 357 {
 358         struct msm_gpu_devfreq *df = container_of(work,
 359                         struct msm_gpu_devfreq, idle_work.work);
 360         struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);
 361
 362         df->idle_time = ktime_get();
 363
 364         if (gpu->clamp_to_idle)
 365                 dev_pm_qos_update_request(&df->idle_freq, 0);
 366 }
 367
 368 void msm_devfreq_idle(struct msm_gpu *gpu)
 369 {
 370         struct msm_gpu_devfreq *df = &gpu->devfreq;
 371
 372         if (!has_devfreq(gpu))
 373                 return;
 374
 375         msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),
 376                                HRTIMER_MODE_REL);
 377 }