projects/linux·blob master · refs

375 lines · 8.8 KiB

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