tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2013 Red Hat
4 * 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/units.h>
13
14/*
15 * Power Management:
16 */
17
18static int msm_devfreq_target(struct device *dev, unsigned long *freq,
19 u32 flags)
20{
21 struct msm_gpu *gpu = dev_to_gpu(dev);
22 struct dev_pm_opp *opp;
23
24 /*
25 * Note that devfreq_recommended_opp() can modify the freq
26 * to something that actually is in the opp table:
27 */
28 opp = devfreq_recommended_opp(dev, freq, flags);
29 if (IS_ERR(opp))
30 return PTR_ERR(opp);
31
32 trace_msm_gpu_freq_change(dev_pm_opp_get_freq(opp));
33
34 if (gpu->funcs->gpu_set_freq)
35 gpu->funcs->gpu_set_freq(gpu, opp);
36 else
37 clk_set_rate(gpu->core_clk, *freq);
38
39 dev_pm_opp_put(opp);
40
41 return 0;
42}
43
44static unsigned long get_freq(struct msm_gpu *gpu)
45{
46 if (gpu->funcs->gpu_get_freq)
47 return gpu->funcs->gpu_get_freq(gpu);
48
49 return clk_get_rate(gpu->core_clk);
50}
51
52static int msm_devfreq_get_dev_status(struct device *dev,
53 struct devfreq_dev_status *status)
54{
55 struct msm_gpu *gpu = dev_to_gpu(dev);
56 ktime_t time;
57
58 status->current_frequency = get_freq(gpu);
59 status->busy_time = gpu->funcs->gpu_busy(gpu);
60
61 time = ktime_get();
62 status->total_time = ktime_us_delta(time, gpu->devfreq.time);
63 gpu->devfreq.time = time;
64
65 return 0;
66}
67
68static int msm_devfreq_get_cur_freq(struct device *dev, unsigned long *freq)
69{
70 *freq = get_freq(dev_to_gpu(dev));
71
72 return 0;
73}
74
75static struct devfreq_dev_profile msm_devfreq_profile = {
76 .timer = DEVFREQ_TIMER_DELAYED,
77 .polling_ms = 50,
78 .target = msm_devfreq_target,
79 .get_dev_status = msm_devfreq_get_dev_status,
80 .get_cur_freq = msm_devfreq_get_cur_freq,
81};
82
83static void msm_devfreq_boost_work(struct kthread_work *work);
84static void msm_devfreq_idle_work(struct kthread_work *work);
85
86static bool has_devfreq(struct msm_gpu *gpu)
87{
88 struct msm_gpu_devfreq *df = &gpu->devfreq;
89 return !!df->devfreq;
90}
91
92void msm_devfreq_init(struct msm_gpu *gpu)
93{
94 struct msm_gpu_devfreq *df = &gpu->devfreq;
95
96 /* We need target support to do devfreq */
97 if (!gpu->funcs->gpu_busy)
98 return;
99
100 dev_pm_qos_add_request(&gpu->pdev->dev, &df->idle_freq,
101 DEV_PM_QOS_MAX_FREQUENCY,
102 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
103 dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq,
104 DEV_PM_QOS_MIN_FREQUENCY, 0);
105
106 msm_devfreq_profile.initial_freq = gpu->fast_rate;
107
108 /*
109 * Don't set the freq_table or max_state and let devfreq build the table
110 * from OPP
111 * After a deferred probe, these may have be left to non-zero values,
112 * so set them back to zero before creating the devfreq device
113 */
114 msm_devfreq_profile.freq_table = NULL;
115 msm_devfreq_profile.max_state = 0;
116
117 df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev,
118 &msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND,
119 NULL);
120
121 if (IS_ERR(df->devfreq)) {
122 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n");
123 df->devfreq = NULL;
124 return;
125 }
126
127 devfreq_suspend_device(df->devfreq);
128
129 gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq);
130 if (IS_ERR(gpu->cooling)) {
131 DRM_DEV_ERROR(&gpu->pdev->dev,
132 "Couldn't register GPU cooling device\n");
133 gpu->cooling = NULL;
134 }
135
136 msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work,
137 CLOCK_MONOTONIC, HRTIMER_MODE_REL);
138 msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work,
139 CLOCK_MONOTONIC, HRTIMER_MODE_REL);
140}
141
142static void cancel_idle_work(struct msm_gpu_devfreq *df)
143{
144 hrtimer_cancel(&df->idle_work.timer);
145 kthread_cancel_work_sync(&df->idle_work.work);
146}
147
148static void cancel_boost_work(struct msm_gpu_devfreq *df)
149{
150 hrtimer_cancel(&df->boost_work.timer);
151 kthread_cancel_work_sync(&df->boost_work.work);
152}
153
154void msm_devfreq_cleanup(struct msm_gpu *gpu)
155{
156 struct msm_gpu_devfreq *df = &gpu->devfreq;
157
158 if (!has_devfreq(gpu))
159 return;
160
161 devfreq_cooling_unregister(gpu->cooling);
162 dev_pm_qos_remove_request(&df->boost_freq);
163 dev_pm_qos_remove_request(&df->idle_freq);
164}
165
166void msm_devfreq_resume(struct msm_gpu *gpu)
167{
168 struct msm_gpu_devfreq *df = &gpu->devfreq;
169
170 if (!has_devfreq(gpu))
171 return;
172
173 df->busy_cycles = 0;
174 df->time = ktime_get();
175
176 devfreq_resume_device(df->devfreq);
177}
178
179void msm_devfreq_suspend(struct msm_gpu *gpu)
180{
181 struct msm_gpu_devfreq *df = &gpu->devfreq;
182
183 if (!has_devfreq(gpu))
184 return;
185
186 devfreq_suspend_device(df->devfreq);
187
188 cancel_idle_work(df);
189 cancel_boost_work(df);
190}
191
192static void msm_devfreq_boost_work(struct kthread_work *work)
193{
194 struct msm_gpu_devfreq *df = container_of(work,
195 struct msm_gpu_devfreq, boost_work.work);
196
197 dev_pm_qos_update_request(&df->boost_freq, 0);
198}
199
200void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor)
201{
202 struct msm_gpu_devfreq *df = &gpu->devfreq;
203 uint64_t freq;
204
205 if (!has_devfreq(gpu))
206 return;
207
208 freq = get_freq(gpu);
209 freq *= factor;
210
211 /*
212 * A nice little trap is that PM QoS operates in terms of KHz,
213 * while devfreq operates in terms of Hz:
214 */
215 do_div(freq, HZ_PER_KHZ);
216
217 dev_pm_qos_update_request(&df->boost_freq, freq);
218
219 msm_hrtimer_queue_work(&df->boost_work,
220 ms_to_ktime(msm_devfreq_profile.polling_ms),
221 HRTIMER_MODE_REL);
222}
223
224void msm_devfreq_active(struct msm_gpu *gpu)
225{
226 struct msm_gpu_devfreq *df = &gpu->devfreq;
227 struct devfreq_dev_status status;
228 unsigned int idle_time;
229
230 if (!has_devfreq(gpu))
231 return;
232
233 /*
234 * Cancel any pending transition to idle frequency:
235 */
236 cancel_idle_work(df);
237
238 idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time));
239
240 /*
241 * If we've been idle for a significant fraction of a polling
242 * interval, then we won't meet the threshold of busyness for
243 * the governor to ramp up the freq.. so give some boost
244 */
245 if (idle_time > msm_devfreq_profile.polling_ms) {
246 msm_devfreq_boost(gpu, 2);
247 }
248
249 dev_pm_qos_update_request(&df->idle_freq,
250 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);
251
252 /*
253 * Reset the polling interval so we aren't inconsistent
254 * about freq vs busy/total cycles
255 */
256 msm_devfreq_get_dev_status(&gpu->pdev->dev, &status);
257}
258
259
260static void msm_devfreq_idle_work(struct kthread_work *work)
261{
262 struct msm_gpu_devfreq *df = container_of(work,
263 struct msm_gpu_devfreq, idle_work.work);
264 struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);
265
266 df->idle_time = ktime_get();
267
268 if (gpu->clamp_to_idle)
269 dev_pm_qos_update_request(&df->idle_freq, 0);
270}
271
272void msm_devfreq_idle(struct msm_gpu *gpu)
273{
274 struct msm_gpu_devfreq *df = &gpu->devfreq;
275
276 if (!has_devfreq(gpu))
277 return;
278
279 msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),
280 HRTIMER_MODE_REL);
281}