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 18 static 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 44 static 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 52 static 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 68 static 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 75 static 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 83 static void msm_devfreq_boost_work(struct kthread_work *work); 84 static void msm_devfreq_idle_work(struct kthread_work *work); 85 86 void msm_devfreq_init(struct msm_gpu *gpu) 87 { 88 struct msm_gpu_devfreq *df = &gpu->devfreq; 89 90 /* We need target support to do devfreq */ 91 if (!gpu->funcs->gpu_busy) 92 return; 93 94 dev_pm_qos_add_request(&gpu->pdev->dev, &df->idle_freq, 95 DEV_PM_QOS_MAX_FREQUENCY, 96 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE); 97 dev_pm_qos_add_request(&gpu->pdev->dev, &df->boost_freq, 98 DEV_PM_QOS_MIN_FREQUENCY, 0); 99 100 msm_devfreq_profile.initial_freq = gpu->fast_rate; 101 102 /* 103 * Don't set the freq_table or max_state and let devfreq build the table 104 * from OPP 105 * After a deferred probe, these may have be left to non-zero values, 106 * so set them back to zero before creating the devfreq device 107 */ 108 msm_devfreq_profile.freq_table = NULL; 109 msm_devfreq_profile.max_state = 0; 110 111 df->devfreq = devm_devfreq_add_device(&gpu->pdev->dev, 112 &msm_devfreq_profile, DEVFREQ_GOV_SIMPLE_ONDEMAND, 113 NULL); 114 115 if (IS_ERR(df->devfreq)) { 116 DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n"); 117 df->devfreq = NULL; 118 return; 119 } 120 121 devfreq_suspend_device(df->devfreq); 122 123 gpu->cooling = of_devfreq_cooling_register(gpu->pdev->dev.of_node, df->devfreq); 124 if (IS_ERR(gpu->cooling)) { 125 DRM_DEV_ERROR(&gpu->pdev->dev, 126 "Couldn't register GPU cooling device\n"); 127 gpu->cooling = NULL; 128 } 129 130 msm_hrtimer_work_init(&df->boost_work, gpu->worker, msm_devfreq_boost_work, 131 CLOCK_MONOTONIC, HRTIMER_MODE_REL); 132 msm_hrtimer_work_init(&df->idle_work, gpu->worker, msm_devfreq_idle_work, 133 CLOCK_MONOTONIC, HRTIMER_MODE_REL); 134 } 135 136 static void cancel_idle_work(struct msm_gpu_devfreq *df) 137 { 138 hrtimer_cancel(&df->idle_work.timer); 139 kthread_cancel_work_sync(&df->idle_work.work); 140 } 141 142 static void cancel_boost_work(struct msm_gpu_devfreq *df) 143 { 144 hrtimer_cancel(&df->boost_work.timer); 145 kthread_cancel_work_sync(&df->boost_work.work); 146 } 147 148 void msm_devfreq_cleanup(struct msm_gpu *gpu) 149 { 150 struct msm_gpu_devfreq *df = &gpu->devfreq; 151 152 devfreq_cooling_unregister(gpu->cooling); 153 dev_pm_qos_remove_request(&df->boost_freq); 154 dev_pm_qos_remove_request(&df->idle_freq); 155 } 156 157 void msm_devfreq_resume(struct msm_gpu *gpu) 158 { 159 gpu->devfreq.busy_cycles = 0; 160 gpu->devfreq.time = ktime_get(); 161 162 devfreq_resume_device(gpu->devfreq.devfreq); 163 } 164 165 void msm_devfreq_suspend(struct msm_gpu *gpu) 166 { 167 struct msm_gpu_devfreq *df = &gpu->devfreq; 168 169 devfreq_suspend_device(df->devfreq); 170 171 cancel_idle_work(df); 172 cancel_boost_work(df); 173 } 174 175 static void msm_devfreq_boost_work(struct kthread_work *work) 176 { 177 struct msm_gpu_devfreq *df = container_of(work, 178 struct msm_gpu_devfreq, boost_work.work); 179 180 dev_pm_qos_update_request(&df->boost_freq, 0); 181 } 182 183 void msm_devfreq_boost(struct msm_gpu *gpu, unsigned factor) 184 { 185 struct msm_gpu_devfreq *df = &gpu->devfreq; 186 uint64_t freq; 187 188 freq = get_freq(gpu); 189 freq *= factor; 190 191 /* 192 * A nice little trap is that PM QoS operates in terms of KHz, 193 * while devfreq operates in terms of Hz: 194 */ 195 do_div(freq, HZ_PER_KHZ); 196 197 dev_pm_qos_update_request(&df->boost_freq, freq); 198 199 msm_hrtimer_queue_work(&df->boost_work, 200 ms_to_ktime(msm_devfreq_profile.polling_ms), 201 HRTIMER_MODE_REL); 202 } 203 204 void msm_devfreq_active(struct msm_gpu *gpu) 205 { 206 struct msm_gpu_devfreq *df = &gpu->devfreq; 207 struct devfreq_dev_status status; 208 unsigned int idle_time; 209 210 if (!df->devfreq) 211 return; 212 213 /* 214 * Cancel any pending transition to idle frequency: 215 */ 216 cancel_idle_work(df); 217 218 idle_time = ktime_to_ms(ktime_sub(ktime_get(), df->idle_time)); 219 220 /* 221 * If we've been idle for a significant fraction of a polling 222 * interval, then we won't meet the threshold of busyness for 223 * the governor to ramp up the freq.. so give some boost 224 */ 225 if (idle_time > msm_devfreq_profile.polling_ms) { 226 msm_devfreq_boost(gpu, 2); 227 } 228 229 dev_pm_qos_update_request(&df->idle_freq, 230 PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE); 231 232 /* 233 * Reset the polling interval so we aren't inconsistent 234 * about freq vs busy/total cycles 235 */ 236 msm_devfreq_get_dev_status(&gpu->pdev->dev, &status); 237 } 238 239 240 static void msm_devfreq_idle_work(struct kthread_work *work) 241 { 242 struct msm_gpu_devfreq *df = container_of(work, 243 struct msm_gpu_devfreq, idle_work.work); 244 struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq); 245 246 df->idle_time = ktime_get(); 247 248 if (gpu->clamp_to_idle) 249 dev_pm_qos_update_request(&df->idle_freq, 0); 250 } 251 252 void msm_devfreq_idle(struct msm_gpu *gpu) 253 { 254 struct msm_gpu_devfreq *df = &gpu->devfreq; 255 256 if (!df->devfreq) 257 return; 258 259 msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1), 260 HRTIMER_MODE_REL); 261 } 262